From a737d461506465510e977d7a6a45af18b744c205 Mon Sep 17 00:00:00 2001 From: Vincenzo Palazzo Date: Sat, 11 Sep 2021 16:16:26 +0200 Subject: [PATCH] Boostrap project. Signed-off-by: Vincenzo Palazzo --- Makefile | 11 + example/example.js | 4036 ++++++++++++++++++++++++ example/example.js.deps | 241 ++ example/example.js.map | 16 + example/main.dart | 6 + lib/bolt12.dart | 1 + lib/bolt_utils.dart | 4 + lib/src/bolt12.dart | 51 + lib/src/core/bolt12_content.dart | 1 + lib/src/core/bolt12_decoder.dart | 49 + lib/src/core/bolt12_encoder.dart | 30 + lib/src/tlv/tlv_core.dart | 78 + lib/src/tlv/tlv_types.dart | 147 + lib/src/tlv/utils/type_converter.dart | 24 + lib/src/utils/bolt_utils.dart | 1 + lib/src/utils/hash_function.dart | 35 + lib/tlv_format.dart | 2 + pubspec.lock | 385 +++ pubspec.yaml | 23 + test/resources/format-string-test.json | 47 + test/test_bolt12.dart | 1 + test/test_hash_function.dart | 15 + 22 files changed, 5204 insertions(+) create mode 100644 Makefile create mode 100644 example/example.js create mode 100644 example/example.js.deps create mode 100644 example/example.js.map create mode 100644 example/main.dart create mode 100644 lib/bolt12.dart create mode 100644 lib/bolt_utils.dart create mode 100644 lib/src/bolt12.dart create mode 100644 lib/src/core/bolt12_content.dart create mode 100644 lib/src/core/bolt12_decoder.dart create mode 100644 lib/src/core/bolt12_encoder.dart create mode 100644 lib/src/tlv/tlv_core.dart create mode 100644 lib/src/tlv/tlv_types.dart create mode 100644 lib/src/tlv/utils/type_converter.dart create mode 100644 lib/src/utils/bolt_utils.dart create mode 100644 lib/src/utils/hash_function.dart create mode 100644 lib/tlv_format.dart create mode 100644 pubspec.lock create mode 100644 pubspec.yaml create mode 100644 test/resources/format-string-test.json create mode 100644 test/test_bolt12.dart create mode 100644 test/test_hash_function.dart diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..d3b68ef --- /dev/null +++ b/Makefile @@ -0,0 +1,11 @@ +CC=dart +FMT=format + +default: fmt + +fmt: + $(CC) $(FMT) . + $(CC) analyze . + +check: + $(CC) test \ No newline at end of file diff --git a/example/example.js b/example/example.js new file mode 100644 index 0000000..462e7d5 --- /dev/null +++ b/example/example.js @@ -0,0 +1,4036 @@ +// Generated by dart2js (NullSafetyMode.sound, no-legacy-javascript), the Dart to JavaScript compiler version: 2.14.1. +// The code supports the following hooks: +// dartPrint(message): +// if this function is defined it is called instead of the Dart [print] +// method. +// +// dartMainRunner(main, args): +// if this function is defined, the Dart [main] method will not be invoked +// directly. Instead, a closure that will invoke [main], and its arguments +// [args] is passed to [dartMainRunner]. +// +// dartDeferredLibraryLoader(uri, successCallback, errorCallback, loadId): +// if this function is defined, it will be called when a deferred library +// is loaded. It should load and eval the javascript of `uri`, and call +// successCallback. If it fails to do so, it should call errorCallback with +// an error. The loadId argument is the deferred import that resulted in +// this uri being loaded. +// +// dartCallInstrumentation(id, qualifiedName): +// if this function is defined, it will be called at each entry of a +// method or constructor. Used only when compiling programs with +// --experiment-call-instrumentation. +(function dartProgram() { + function copyProperties(from, to) { + var keys = Object.keys(from); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + to[key] = from[key]; + } + } + function mixinProperties(from, to) { + var keys = Object.keys(from); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!to.hasOwnProperty(key)) + to[key] = from[key]; + } + } + var supportsDirectProtoAccess = function() { + var cls = function() { + }; + cls.prototype = {p: {}}; + var object = new cls(); + if (!(object.__proto__ && object.__proto__.p === cls.prototype.p)) + return false; + try { + if (typeof navigator != "undefined" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome/") >= 0) + return true; + if (typeof version == "function" && version.length == 0) { + var v = version(); + if (/^\d+\.\d+\.\d+\.\d+$/.test(v)) + return true; + } + } catch (_) { + } + return false; + }(); + function setFunctionNamesIfNecessary(holders) { + function t() { + } + ; + if (typeof t.name == "string") + return; + for (var i = 0; i < holders.length; i++) { + var holder = holders[i]; + var keys = Object.keys(holder); + for (var j = 0; j < keys.length; j++) { + var key = keys[j]; + var f = holder[key]; + if (typeof f == "function") + f.name = key; + } + } + } + function inherit(cls, sup) { + cls.prototype.constructor = cls; + cls.prototype["$is" + cls.name] = cls; + if (sup != null) { + if (supportsDirectProtoAccess) { + cls.prototype.__proto__ = sup.prototype; + return; + } + var clsPrototype = Object.create(sup.prototype); + copyProperties(cls.prototype, clsPrototype); + cls.prototype = clsPrototype; + } + } + function inheritMany(sup, classes) { + for (var i = 0; i < classes.length; i++) + inherit(classes[i], sup); + } + function mixin(cls, mixin) { + mixinProperties(mixin.prototype, cls.prototype); + cls.prototype.constructor = cls; + } + function lazyOld(holder, name, getterName, initializer) { + var uninitializedSentinel = holder; + holder[name] = uninitializedSentinel; + holder[getterName] = function() { + holder[getterName] = function() { + H.throwCyclicInit(name); + }; + var result; + var sentinelInProgress = initializer; + try { + if (holder[name] === uninitializedSentinel) { + result = holder[name] = sentinelInProgress; + result = holder[name] = initializer(); + } else + result = holder[name]; + } finally { + if (result === sentinelInProgress) + holder[name] = null; + holder[getterName] = function() { + return this[name]; + }; + } + return result; + }; + } + function lazy(holder, name, getterName, initializer) { + var uninitializedSentinel = holder; + holder[name] = uninitializedSentinel; + holder[getterName] = function() { + if (holder[name] === uninitializedSentinel) + holder[name] = initializer(); + holder[getterName] = function() { + return this[name]; + }; + return holder[name]; + }; + } + function lazyFinal(holder, name, getterName, initializer) { + var uninitializedSentinel = holder; + holder[name] = uninitializedSentinel; + holder[getterName] = function() { + if (holder[name] === uninitializedSentinel) { + var value = initializer(); + if (holder[name] !== uninitializedSentinel) + H.throwLateFieldADI(name); + holder[name] = value; + } + holder[getterName] = function() { + return this[name]; + }; + return holder[name]; + }; + } + function makeConstList(list) { + list.immutable$list = Array; + list.fixed$length = Array; + return list; + } + function convertToFastObject(properties) { + function t() { + } + t.prototype = properties; + new t(); + return properties; + } + function convertAllToFastObject(arrayOfObjects) { + for (var i = 0; i < arrayOfObjects.length; ++i) + convertToFastObject(arrayOfObjects[i]); + } + var functionCounter = 0; + function instanceTearOffGetter(isIntercepted, parameters) { + var name = parameters.fs[0]; + if (isIntercepted) + return new Function("parameters, createTearOffClass, cache", "return function tearOff_" + name + functionCounter++ + "(receiver) {" + "if (cache === null) cache = createTearOffClass(parameters);" + "return new cache(receiver, this);" + "}")(parameters, H.closureFromTearOff, null); + else + return new Function("parameters, createTearOffClass, cache", "return function tearOff_" + name + functionCounter++ + "() {" + "if (cache === null) cache = createTearOffClass(parameters);" + "return new cache(this, null);" + "}")(parameters, H.closureFromTearOff, null); + } + function staticTearOffGetter(parameters) { + var cache = null; + return function() { + if (cache === null) + cache = H.closureFromTearOff(parameters).prototype; + return cache; + }; + } + var typesOffset = 0; + function tearOffParameters(container, isStatic, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) { + if (typeof funType == "number") + funType += typesOffset; + return {co: container, iS: isStatic, iI: isIntercepted, rC: requiredParameterCount, dV: optionalParameterDefaultValues, cs: callNames, fs: funsOrNames, fT: funType, aI: applyIndex || 0, nDA: needsDirectAccess}; + } + function installStaticTearOff(holder, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) { + var parameters = tearOffParameters(holder, true, false, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, false); + var getterFunction = staticTearOffGetter(parameters); + holder[getterName] = getterFunction; + } + function installInstanceTearOff(prototype, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) { + isIntercepted = !!isIntercepted; + var parameters = tearOffParameters(prototype, false, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, !!needsDirectAccess); + var getterFunction = instanceTearOffGetter(isIntercepted, parameters); + prototype[getterName] = getterFunction; + } + function setOrUpdateInterceptorsByTag(newTags) { + var tags = init.interceptorsByTag; + if (!tags) { + init.interceptorsByTag = newTags; + return; + } + copyProperties(newTags, tags); + } + function setOrUpdateLeafTags(newTags) { + var tags = init.leafTags; + if (!tags) { + init.leafTags = newTags; + return; + } + copyProperties(newTags, tags); + } + function updateTypes(newTypes) { + var types = init.types; + var length = types.length; + types.push.apply(types, newTypes); + return length; + } + function updateHolder(holder, newHolder) { + copyProperties(newHolder, holder); + return holder; + } + var hunkHelpers = function() { + var mkInstance = function(isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) { + return function(container, getterName, name, funType) { + return installInstanceTearOff(container, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex, false); + }; + }, + mkStatic = function(requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) { + return function(container, getterName, name, funType) { + return installStaticTearOff(container, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex); + }; + }; + return {inherit: inherit, inheritMany: inheritMany, mixin: mixin, installStaticTearOff: installStaticTearOff, installInstanceTearOff: installInstanceTearOff, _instance_0u: mkInstance(0, 0, null, ["call$0"], 0), _instance_1u: mkInstance(0, 1, null, ["call$1"], 0), _instance_2u: mkInstance(0, 2, null, ["call$2"], 0), _instance_0i: mkInstance(1, 0, null, ["call$0"], 0), _instance_1i: mkInstance(1, 1, null, ["call$1"], 0), _instance_2i: mkInstance(1, 2, null, ["call$2"], 0), _static_0: mkStatic(0, null, ["call$0"], 0), _static_1: mkStatic(1, null, ["call$1"], 0), _static_2: mkStatic(2, null, ["call$2"], 0), makeConstList: makeConstList, lazy: lazy, lazyFinal: lazyFinal, lazyOld: lazyOld, updateHolder: updateHolder, convertToFastObject: convertToFastObject, setFunctionNamesIfNecessary: setFunctionNamesIfNecessary, updateTypes: updateTypes, setOrUpdateInterceptorsByTag: setOrUpdateInterceptorsByTag, setOrUpdateLeafTags: setOrUpdateLeafTags}; + }(); + function initializeDeferredHunk(hunk) { + typesOffset = init.types.length; + hunk(hunkHelpers, init, holders, $); + } + var C = {}, + F = { + main() { + var t2, t3, + t1 = new M.Bolt12Encoder(); + t1.__Bolt12Encoder__bech32codec = new O.Bech32Codec(); + K.Bolt12Decoder$(); + t2 = new Z.HashFunction(); + t2.__HashFunction__hasher = type$.Hash._as(t2.get$sha256()); + t2 = type$.int; + t3 = type$.List_int; + type$.Map_of_int_and_List_dynamic._as(P.LinkedHashMap_LinkedHashMap$_empty(t2, type$.List_dynamic)); + type$.Map_int_dynamic._as(P.LinkedHashMap_LinkedHashMap$_empty(t2, type$.dynamic)); + type$.Map_of_int_and_List_int._as(P.LinkedHashMap_LinkedHashMap$_empty(t2, t3)); + t3 = t3._as(H._setArrayType([], type$.JSArray_int)); + if (t1.__Bolt12Encoder__bech32codec == null) + H.throwExpression(H.LateError$fieldNI("_bech32codec")); + P.print(new O.Bech32Encoder().convert$2(new O.Bech32("hrp1", t3), 90)); + } + }, + H = {JS_CONST: function JS_CONST() { + }, + LateError$fieldNI(fieldName) { + return new H.LateError("Field '" + fieldName + "' has not been initialized."); + }, + LateError: function LateError(t0) { + this._message = t0; + }, + CodeUnits: function CodeUnits(t0) { + this._string = t0; + }, + EfficientLengthIterable: function EfficientLengthIterable() { + }, + ListIterable: function ListIterable() { + }, + ListIterator: function ListIterator(t0, t1, t2) { + var _ = this; + _.__internal$_iterable = t0; + _.__internal$_length = t1; + _.__internal$_index = 0; + _.__internal$_current = null; + _.$ti = t2; + }, + MappedListIterable: function MappedListIterable(t0, t1, t2) { + this._source = t0; + this._f = t1; + this.$ti = t2; + }, + FixedLengthListMixin: function FixedLengthListMixin() { + }, + UnmodifiableListMixin: function UnmodifiableListMixin() { + }, + UnmodifiableListBase: function UnmodifiableListBase() { + }, + unminifyOrTag(rawClassName) { + var preserved = init.mangledGlobalNames[rawClassName]; + if (preserved != null) + return preserved; + return rawClassName; + }, + isJsIndexable(object, record) { + var result; + if (record != null) { + result = record.x; + if (result != null) + return result; + } + return type$.JavaScriptIndexingBehavior_dynamic._is(object); + }, + S(value) { + var res; + if (typeof value == "string") + return value; + if (typeof value == "number") { + if (value !== 0) + return "" + value; + } else if (true === value) + return "true"; + else if (false === value) + return "false"; + else if (value == null) + return "null"; + res = J.toString$0$(value); + return res; + }, + Primitives_objectTypeName(object) { + return H.Primitives__objectTypeNameNewRti(object); + }, + Primitives__objectTypeNameNewRti(object) { + var dispatchName, t1, $constructor, constructorName; + if (object instanceof P.Object) + return H._rtiToString(H.instanceType(object), null); + if (J.getInterceptor$(object) === C.Interceptor_methods || type$.UnknownJavaScriptObject._is(object)) { + dispatchName = C.C_JS_CONST(object); + t1 = dispatchName !== "Object" && dispatchName !== ""; + if (t1) + return dispatchName; + $constructor = object.constructor; + if (typeof $constructor == "function") { + constructorName = $constructor.name; + if (typeof constructorName == "string") + t1 = constructorName !== "Object" && constructorName !== ""; + else + t1 = false; + if (t1) + return constructorName; + } + } + return H._rtiToString(H.instanceType(object), null); + }, + ioore(receiver, index) { + if (receiver == null) + J.get$length$asx(receiver); + throw H.wrapException(H.diagnoseIndexError(receiver, index)); + }, + diagnoseIndexError(indexable, index) { + var $length, _s5_ = "index", _null = null; + if (!H._isInt(index)) + return new P.ArgumentError(true, index, _s5_, _null); + $length = J.get$length$asx(indexable); + if (index < 0 || index >= $length) + return P.IndexError$(index, indexable, _s5_, _null, $length); + return new P.RangeError(_null, _null, true, index, _s5_, "Value not in range"); + }, + diagnoseRangeError(start, end, $length) { + if (start > $length) + return P.RangeError$range(start, 0, $length, "start", null); + if (end != null) + if (end < start || end > $length) + return P.RangeError$range(end, start, $length, "end", null); + return new P.ArgumentError(true, end, "end", null); + }, + argumentErrorValue(object) { + return new P.ArgumentError(true, object, null, null); + }, + wrapException(ex) { + var wrapper, t1; + if (ex == null) + ex = new P.NullThrownError(); + wrapper = new Error(); + wrapper.dartException = ex; + t1 = H.toStringWrapper; + if ("defineProperty" in Object) { + Object.defineProperty(wrapper, "message", {get: t1}); + wrapper.name = ""; + } else + wrapper.toString = t1; + return wrapper; + }, + toStringWrapper() { + return J.toString$0$(this.dartException); + }, + throwExpression(ex) { + throw H.wrapException(ex); + }, + throwConcurrentModificationError(collection) { + throw H.wrapException(P.ConcurrentModificationError$(collection)); + }, + Closure_fromTearOff(parameters) { + var $prototype, $constructor, t2, trampoline, applyTrampoline, i, stub, stub0, stubName, stubCallName, + container = parameters.co, + isStatic = parameters.iS, + isIntercepted = parameters.iI, + needsDirectAccess = parameters.nDA, + applyTrampolineIndex = parameters.aI, + funsOrNames = parameters.fs, + callNames = parameters.cs, + $name = funsOrNames[0], + callName = callNames[0], + $function = container[$name], + t1 = parameters.fT; + t1.toString; + $prototype = isStatic ? Object.create(new H.StaticClosure().constructor.prototype) : Object.create(new H.BoundClosure(null, null).constructor.prototype); + $prototype.$initialize = $prototype.constructor; + if (isStatic) + $constructor = function static_tear_off() { + this.$initialize(); + }; + else { + t2 = $.Closure_functionCounter; + if (typeof t2 !== "number") + return t2.$add(); + $.Closure_functionCounter = t2 + 1; + t2 = new Function("a,b" + t2, "this.$initialize(a,b" + t2 + ")"); + $constructor = t2; + } + $prototype.constructor = $constructor; + $constructor.prototype = $prototype; + $prototype.$_name = $name; + $prototype.$_target = $function; + t2 = !isStatic; + if (t2) + trampoline = H.Closure_forwardCallTo($name, $function, isIntercepted, needsDirectAccess); + else { + $prototype.$static_name = $name; + trampoline = $function; + } + $prototype.$signature = H.Closure__computeSignatureFunctionNewRti(t1, isStatic, isIntercepted); + $prototype[callName] = trampoline; + for (applyTrampoline = trampoline, i = 1; i < funsOrNames.length; ++i) { + stub = funsOrNames[i]; + if (typeof stub == "string") { + stub0 = container[stub]; + stubName = stub; + stub = stub0; + } else + stubName = ""; + stubCallName = callNames[i]; + if (stubCallName != null) { + if (t2) + stub = H.Closure_forwardCallTo(stubName, stub, isIntercepted, needsDirectAccess); + $prototype[stubCallName] = stub; + } + if (i === applyTrampolineIndex) + applyTrampoline = stub; + } + $prototype["call*"] = applyTrampoline; + $prototype.$requiredArgCount = parameters.rC; + $prototype.$defaultValues = parameters.dV; + return $constructor; + }, + Closure__computeSignatureFunctionNewRti(functionType, isStatic, isIntercepted) { + if (typeof functionType == "number") + return functionType; + if (typeof functionType == "string") { + if (isStatic) + throw H.wrapException("Cannot compute signature for static tearoff."); + return function(recipe, evalOnReceiver) { + return function() { + return evalOnReceiver(this, recipe); + }; + }(functionType, H.BoundClosure_evalRecipe); + } + throw H.wrapException("Error in functionType of tearoff"); + }, + Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function) { + var getReceiver = H.BoundClosure_receiverOf; + switch (needsDirectAccess ? -1 : arity) { + case 0: + return function(entry, receiverOf) { + return function() { + return receiverOf(this)[entry](); + }; + }(stubName, getReceiver); + case 1: + return function(entry, receiverOf) { + return function(a) { + return receiverOf(this)[entry](a); + }; + }(stubName, getReceiver); + case 2: + return function(entry, receiverOf) { + return function(a, b) { + return receiverOf(this)[entry](a, b); + }; + }(stubName, getReceiver); + case 3: + return function(entry, receiverOf) { + return function(a, b, c) { + return receiverOf(this)[entry](a, b, c); + }; + }(stubName, getReceiver); + case 4: + return function(entry, receiverOf) { + return function(a, b, c, d) { + return receiverOf(this)[entry](a, b, c, d); + }; + }(stubName, getReceiver); + case 5: + return function(entry, receiverOf) { + return function(a, b, c, d, e) { + return receiverOf(this)[entry](a, b, c, d, e); + }; + }(stubName, getReceiver); + default: + return function(f, receiverOf) { + return function() { + return f.apply(receiverOf(this), arguments); + }; + }($function, getReceiver); + } + }, + Closure_forwardCallTo(stubName, $function, isIntercepted, needsDirectAccess) { + var arity, t1, selfName, t2, $arguments, + _s8_ = "receiver"; + if (isIntercepted) + return H.Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess); + arity = $function.length; + t1 = needsDirectAccess || arity >= 27; + if (t1) + return H.Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function); + if (arity === 0) { + t1 = $.Closure_functionCounter; + if (typeof t1 !== "number") + return t1.$add(); + $.Closure_functionCounter = t1 + 1; + selfName = "self" + t1; + t1 = "return function(){var " + selfName + " = this."; + t2 = $.BoundClosure__receiverFieldNameCache; + return new Function(t1 + (t2 == null ? $.BoundClosure__receiverFieldNameCache = H.BoundClosure__computeFieldNamed(_s8_) : t2) + ";return " + selfName + "." + stubName + "();}")(); + } + $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(","); + t1 = $.Closure_functionCounter; + if (typeof t1 !== "number") + return t1.$add(); + $.Closure_functionCounter = t1 + 1; + $arguments += t1; + t1 = "return function(" + $arguments + "){return this."; + t2 = $.BoundClosure__receiverFieldNameCache; + return new Function(t1 + (t2 == null ? $.BoundClosure__receiverFieldNameCache = H.BoundClosure__computeFieldNamed(_s8_) : t2) + "." + stubName + "(" + $arguments + ");}")(); + }, + Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function) { + var getReceiver = H.BoundClosure_receiverOf, + getInterceptor = H.BoundClosure_interceptorOf; + switch (needsDirectAccess ? -1 : arity) { + case 0: + throw H.wrapException(new H.RuntimeError("Intercepted function with no arguments.")); + case 1: + return function(entry, interceptorOf, receiverOf) { + return function() { + return interceptorOf(this)[entry](receiverOf(this)); + }; + }(stubName, getInterceptor, getReceiver); + case 2: + return function(entry, interceptorOf, receiverOf) { + return function(a) { + return interceptorOf(this)[entry](receiverOf(this), a); + }; + }(stubName, getInterceptor, getReceiver); + case 3: + return function(entry, interceptorOf, receiverOf) { + return function(a, b) { + return interceptorOf(this)[entry](receiverOf(this), a, b); + }; + }(stubName, getInterceptor, getReceiver); + case 4: + return function(entry, interceptorOf, receiverOf) { + return function(a, b, c) { + return interceptorOf(this)[entry](receiverOf(this), a, b, c); + }; + }(stubName, getInterceptor, getReceiver); + case 5: + return function(entry, interceptorOf, receiverOf) { + return function(a, b, c, d) { + return interceptorOf(this)[entry](receiverOf(this), a, b, c, d); + }; + }(stubName, getInterceptor, getReceiver); + case 6: + return function(entry, interceptorOf, receiverOf) { + return function(a, b, c, d, e) { + return interceptorOf(this)[entry](receiverOf(this), a, b, c, d, e); + }; + }(stubName, getInterceptor, getReceiver); + default: + return function(f, interceptorOf, receiverOf) { + return function() { + var a = [receiverOf(this)]; + Array.prototype.push.apply(a, arguments); + return f.apply(interceptorOf(this), a); + }; + }($function, getInterceptor, getReceiver); + } + }, + Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess) { + var receiverField, arity, t1, t2, $arguments, + interceptorField = $.BoundClosure__interceptorFieldNameCache; + if (interceptorField == null) + interceptorField = $.BoundClosure__interceptorFieldNameCache = H.BoundClosure__computeFieldNamed("interceptor"); + receiverField = $.BoundClosure__receiverFieldNameCache; + if (receiverField == null) + receiverField = $.BoundClosure__receiverFieldNameCache = H.BoundClosure__computeFieldNamed("receiver"); + arity = $function.length; + t1 = needsDirectAccess || arity >= 28; + if (t1) + return H.Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function); + if (arity === 1) { + t1 = "return function(){return this." + interceptorField + "." + stubName + "(this." + receiverField + ");"; + t2 = $.Closure_functionCounter; + if (typeof t2 !== "number") + return t2.$add(); + $.Closure_functionCounter = t2 + 1; + return new Function(t1 + t2 + "}")(); + } + $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity - 1).join(","); + t1 = "return function(" + $arguments + "){return this." + interceptorField + "." + stubName + "(this." + receiverField + ", " + $arguments + ");"; + t2 = $.Closure_functionCounter; + if (typeof t2 !== "number") + return t2.$add(); + $.Closure_functionCounter = t2 + 1; + return new Function(t1 + t2 + "}")(); + }, + closureFromTearOff(parameters) { + return H.Closure_fromTearOff(parameters); + }, + BoundClosure_evalRecipe(closure, recipe) { + return H._Universe_evalInEnvironment(init.typeUniverse, H.instanceType(closure._receiver), recipe); + }, + BoundClosure_receiverOf(closure) { + return closure._receiver; + }, + BoundClosure_interceptorOf(closure) { + return closure._interceptor; + }, + BoundClosure__computeFieldNamed(fieldName) { + var t1, i, $name, + template = new H.BoundClosure("receiver", "interceptor"), + names = J.JSArray_markFixedList(Object.getOwnPropertyNames(template), type$.nullable_Object); + for (t1 = names.length, i = 0; i < t1; ++i) { + $name = names[i]; + if (template[$name] === fieldName) + return $name; + } + throw H.wrapException(P.ArgumentError$("Field name " + fieldName + " not found.")); + }, + boolConversionCheck(value) { + if (value == null) + H.assertThrow("boolean expression must not be null"); + return value; + }, + assertThrow(message) { + throw H.wrapException(new H._AssertionError(message)); + }, + throwCyclicInit(staticName) { + throw H.wrapException(new P.CyclicInitializationError(staticName)); + }, + getIsolateAffinityTag($name) { + return init.getIsolateTag($name); + }, + lookupAndCacheInterceptor(obj) { + var interceptor, interceptorClass, altTag, mark, t1, + tag = H._asString($.getTagFunction.call$1(obj)), + record = $.dispatchRecordsForInstanceTags[tag]; + if (record != null) { + Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + return record.i; + } + interceptor = $.interceptorsForUncacheableTags[tag]; + if (interceptor != null) + return interceptor; + interceptorClass = init.interceptorsByTag[tag]; + if (interceptorClass == null) { + altTag = H._asStringQ($.alternateTagFunction.call$2(obj, tag)); + if (altTag != null) { + record = $.dispatchRecordsForInstanceTags[altTag]; + if (record != null) { + Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + return record.i; + } + interceptor = $.interceptorsForUncacheableTags[altTag]; + if (interceptor != null) + return interceptor; + interceptorClass = init.interceptorsByTag[altTag]; + tag = altTag; + } + } + if (interceptorClass == null) + return null; + interceptor = interceptorClass.prototype; + mark = tag[0]; + if (mark === "!") { + record = H.makeLeafDispatchRecord(interceptor); + $.dispatchRecordsForInstanceTags[tag] = record; + Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + return record.i; + } + if (mark === "~") { + $.interceptorsForUncacheableTags[tag] = interceptor; + return interceptor; + } + if (mark === "-") { + t1 = H.makeLeafDispatchRecord(interceptor); + Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); + return t1.i; + } + if (mark === "+") + return H.patchInteriorProto(obj, interceptor); + if (mark === "*") + throw H.wrapException(P.UnimplementedError$(tag)); + if (init.leafTags[tag] === true) { + t1 = H.makeLeafDispatchRecord(interceptor); + Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); + return t1.i; + } else + return H.patchInteriorProto(obj, interceptor); + }, + patchInteriorProto(obj, interceptor) { + var proto = Object.getPrototypeOf(obj); + Object.defineProperty(proto, init.dispatchPropertyName, {value: J.makeDispatchRecord(interceptor, proto, null, null), enumerable: false, writable: true, configurable: true}); + return interceptor; + }, + makeLeafDispatchRecord(interceptor) { + return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior); + }, + makeDefaultDispatchRecord(tag, interceptorClass, proto) { + var interceptor = interceptorClass.prototype; + if (init.leafTags[tag] === true) + return H.makeLeafDispatchRecord(interceptor); + else + return J.makeDispatchRecord(interceptor, proto, null, null); + }, + initNativeDispatch() { + if (true === $.initNativeDispatchFlag) + return; + $.initNativeDispatchFlag = true; + H.initNativeDispatchContinue(); + }, + initNativeDispatchContinue() { + var map, tags, fun, i, tag, proto, record, interceptorClass; + $.dispatchRecordsForInstanceTags = Object.create(null); + $.interceptorsForUncacheableTags = Object.create(null); + H.initHooks(); + map = init.interceptorsByTag; + tags = Object.getOwnPropertyNames(map); + if (typeof window != "undefined") { + window; + fun = function() { + }; + for (i = 0; i < tags.length; ++i) { + tag = tags[i]; + proto = $.prototypeForTagFunction.call$1(tag); + if (proto != null) { + record = H.makeDefaultDispatchRecord(tag, map[tag], proto); + if (record != null) { + Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); + fun.prototype = proto; + } + } + } + } + for (i = 0; i < tags.length; ++i) { + tag = tags[i]; + if (/^[A-Za-z_]/.test(tag)) { + interceptorClass = map[tag]; + map["!" + tag] = interceptorClass; + map["~" + tag] = interceptorClass; + map["-" + tag] = interceptorClass; + map["+" + tag] = interceptorClass; + map["*" + tag] = interceptorClass; + } + } + }, + initHooks() { + var transformers, i, transformer, getTag, getUnknownTag, prototypeForTag, + hooks = C.C_JS_CONST0(); + hooks = H.applyHooksTransformer(C.C_JS_CONST1, H.applyHooksTransformer(C.C_JS_CONST2, H.applyHooksTransformer(C.C_JS_CONST3, H.applyHooksTransformer(C.C_JS_CONST3, H.applyHooksTransformer(C.C_JS_CONST4, H.applyHooksTransformer(C.C_JS_CONST5, H.applyHooksTransformer(C.C_JS_CONST6(C.C_JS_CONST), hooks))))))); + if (typeof dartNativeDispatchHooksTransformer != "undefined") { + transformers = dartNativeDispatchHooksTransformer; + if (typeof transformers == "function") + transformers = [transformers]; + if (transformers.constructor == Array) + for (i = 0; i < transformers.length; ++i) { + transformer = transformers[i]; + if (typeof transformer == "function") + hooks = transformer(hooks) || hooks; + } + } + getTag = hooks.getTag; + getUnknownTag = hooks.getUnknownTag; + prototypeForTag = hooks.prototypeForTag; + $.getTagFunction = new H.initHooks_closure(getTag); + $.alternateTagFunction = new H.initHooks_closure0(getUnknownTag); + $.prototypeForTagFunction = new H.initHooks_closure1(prototypeForTag); + }, + applyHooksTransformer(transformer, hooks) { + return transformer(hooks) || hooks; + }, + Closure: function Closure() { + }, + Closure0Args: function Closure0Args() { + }, + Closure2Args: function Closure2Args() { + }, + TearOffClosure: function TearOffClosure() { + }, + StaticClosure: function StaticClosure() { + }, + BoundClosure: function BoundClosure(t0, t1) { + this._receiver = t0; + this._interceptor = t1; + }, + RuntimeError: function RuntimeError(t0) { + this.message = t0; + }, + _AssertionError: function _AssertionError(t0) { + this.message = t0; + }, + JsLinkedHashMap: function JsLinkedHashMap(t0) { + var _ = this; + _.__js_helper$_length = 0; + _._last = _._first = _.__js_helper$_rest = _._nums = _._strings = null; + _._modifications = 0; + _.$ti = t0; + }, + initHooks_closure: function initHooks_closure(t0) { + this.getTag = t0; + }, + initHooks_closure0: function initHooks_closure0(t0) { + this.getUnknownTag = t0; + }, + initHooks_closure1: function initHooks_closure1(t0) { + this.prototypeForTag = t0; + }, + _checkValidIndex(index, list, $length) { + if (index >>> 0 !== index || index >= $length) + throw H.wrapException(H.diagnoseIndexError(list, index)); + }, + _checkValidRange(start, end, $length) { + var t1; + if (!(start >>> 0 !== start)) + t1 = end >>> 0 !== end || start > end || end > $length; + else + t1 = true; + if (t1) + throw H.wrapException(H.diagnoseRangeError(start, end, $length)); + return end; + }, + NativeTypedData: function NativeTypedData() { + }, + NativeTypedArray: function NativeTypedArray() { + }, + NativeTypedArrayOfInt: function NativeTypedArrayOfInt() { + }, + NativeUint8List: function NativeUint8List() { + }, + _NativeTypedArrayOfInt_NativeTypedArray_ListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin() { + }, + _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin() { + }, + Rti__getQuestionFromStar(universe, rti) { + var question = rti._precomputed1; + return question == null ? rti._precomputed1 = H._Universe__lookupQuestionRti(universe, rti._primary, true) : question; + }, + Rti__getFutureFromFutureOr(universe, rti) { + var future = rti._precomputed1; + return future == null ? rti._precomputed1 = H._Universe__lookupInterfaceRti(universe, "Future", [rti._primary]) : future; + }, + Rti__isUnionOfFunctionType(rti) { + var kind = rti._kind; + if (kind === 6 || kind === 7 || kind === 8) + return H.Rti__isUnionOfFunctionType(rti._primary); + return kind === 11 || kind === 12; + }, + Rti__getCanonicalRecipe(rti) { + return rti._canonicalRecipe; + }, + findType(recipe) { + return H._Universe_eval(init.typeUniverse, recipe, false); + }, + _substitute(universe, rti, typeArguments, depth) { + var baseType, substitutedBaseType, interfaceTypeArguments, substitutedInterfaceTypeArguments, base, substitutedBase, $arguments, substitutedArguments, returnType, substitutedReturnType, functionParameters, substitutedFunctionParameters, bounds, substitutedBounds, index, argument, + kind = rti._kind; + switch (kind) { + case 5: + case 1: + case 2: + case 3: + case 4: + return rti; + case 6: + baseType = rti._primary; + substitutedBaseType = H._substitute(universe, baseType, typeArguments, depth); + if (substitutedBaseType === baseType) + return rti; + return H._Universe__lookupStarRti(universe, substitutedBaseType, true); + case 7: + baseType = rti._primary; + substitutedBaseType = H._substitute(universe, baseType, typeArguments, depth); + if (substitutedBaseType === baseType) + return rti; + return H._Universe__lookupQuestionRti(universe, substitutedBaseType, true); + case 8: + baseType = rti._primary; + substitutedBaseType = H._substitute(universe, baseType, typeArguments, depth); + if (substitutedBaseType === baseType) + return rti; + return H._Universe__lookupFutureOrRti(universe, substitutedBaseType, true); + case 9: + interfaceTypeArguments = rti._rest; + substitutedInterfaceTypeArguments = H._substituteArray(universe, interfaceTypeArguments, typeArguments, depth); + if (substitutedInterfaceTypeArguments === interfaceTypeArguments) + return rti; + return H._Universe__lookupInterfaceRti(universe, rti._primary, substitutedInterfaceTypeArguments); + case 10: + base = rti._primary; + substitutedBase = H._substitute(universe, base, typeArguments, depth); + $arguments = rti._rest; + substitutedArguments = H._substituteArray(universe, $arguments, typeArguments, depth); + if (substitutedBase === base && substitutedArguments === $arguments) + return rti; + return H._Universe__lookupBindingRti(universe, substitutedBase, substitutedArguments); + case 11: + returnType = rti._primary; + substitutedReturnType = H._substitute(universe, returnType, typeArguments, depth); + functionParameters = rti._rest; + substitutedFunctionParameters = H._substituteFunctionParameters(universe, functionParameters, typeArguments, depth); + if (substitutedReturnType === returnType && substitutedFunctionParameters === functionParameters) + return rti; + return H._Universe__lookupFunctionRti(universe, substitutedReturnType, substitutedFunctionParameters); + case 12: + bounds = rti._rest; + depth += bounds.length; + substitutedBounds = H._substituteArray(universe, bounds, typeArguments, depth); + base = rti._primary; + substitutedBase = H._substitute(universe, base, typeArguments, depth); + if (substitutedBounds === bounds && substitutedBase === base) + return rti; + return H._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, true); + case 13: + index = rti._primary; + if (index < depth) + return rti; + argument = typeArguments[index - depth]; + if (argument == null) + return rti; + return argument; + default: + throw H.wrapException(P.AssertionError$("Attempted to substitute unexpected RTI kind " + kind)); + } + }, + _substituteArray(universe, rtiArray, typeArguments, depth) { + var changed, i, rti, substitutedRti, + $length = rtiArray.length, + result = H._Utils_newArrayOrEmpty($length); + for (changed = false, i = 0; i < $length; ++i) { + rti = rtiArray[i]; + substitutedRti = H._substitute(universe, rti, typeArguments, depth); + if (substitutedRti !== rti) + changed = true; + result[i] = substitutedRti; + } + return changed ? result : rtiArray; + }, + _substituteNamed(universe, namedArray, typeArguments, depth) { + var changed, i, t1, t2, rti, substitutedRti, + $length = namedArray.length, + result = H._Utils_newArrayOrEmpty($length); + for (changed = false, i = 0; i < $length; i += 3) { + t1 = namedArray[i]; + t2 = namedArray[i + 1]; + rti = namedArray[i + 2]; + substitutedRti = H._substitute(universe, rti, typeArguments, depth); + if (substitutedRti !== rti) + changed = true; + result.splice(i, 3, t1, t2, substitutedRti); + } + return changed ? result : namedArray; + }, + _substituteFunctionParameters(universe, functionParameters, typeArguments, depth) { + var result, + requiredPositional = functionParameters._requiredPositional, + substitutedRequiredPositional = H._substituteArray(universe, requiredPositional, typeArguments, depth), + optionalPositional = functionParameters._optionalPositional, + substitutedOptionalPositional = H._substituteArray(universe, optionalPositional, typeArguments, depth), + named = functionParameters._named, + substitutedNamed = H._substituteNamed(universe, named, typeArguments, depth); + if (substitutedRequiredPositional === requiredPositional && substitutedOptionalPositional === optionalPositional && substitutedNamed === named) + return functionParameters; + result = new H._FunctionParameters(); + result._requiredPositional = substitutedRequiredPositional; + result._optionalPositional = substitutedOptionalPositional; + result._named = substitutedNamed; + return result; + }, + _setArrayType(target, rti) { + target[init.arrayRti] = rti; + return target; + }, + closureFunctionType(closure) { + var signature = closure.$signature; + if (signature != null) { + if (typeof signature == "number") + return H.getTypeFromTypesTable(signature); + return closure.$signature(); + } + return null; + }, + instanceOrFunctionType(object, testRti) { + var rti; + if (H.Rti__isUnionOfFunctionType(testRti)) + if (object instanceof H.Closure) { + rti = H.closureFunctionType(object); + if (rti != null) + return rti; + } + return H.instanceType(object); + }, + instanceType(object) { + var rti; + if (object instanceof P.Object) { + rti = object.$ti; + return rti != null ? rti : H._instanceTypeFromConstructor(object); + } + if (Array.isArray(object)) + return H._arrayInstanceType(object); + return H._instanceTypeFromConstructor(J.getInterceptor$(object)); + }, + _arrayInstanceType(object) { + var rti = object[init.arrayRti], + defaultRti = type$.JSArray_dynamic; + if (rti == null) + return defaultRti; + if (rti.constructor !== defaultRti.constructor) + return defaultRti; + return rti; + }, + _instanceType(object) { + var rti = object.$ti; + return rti != null ? rti : H._instanceTypeFromConstructor(object); + }, + _instanceTypeFromConstructor(instance) { + var $constructor = instance.constructor, + probe = $constructor.$ccache; + if (probe != null) + return probe; + return H._instanceTypeFromConstructorMiss(instance, $constructor); + }, + _instanceTypeFromConstructorMiss(instance, $constructor) { + var effectiveConstructor = instance instanceof H.Closure ? instance.__proto__.__proto__.constructor : $constructor, + rti = H._Universe_findErasedType(init.typeUniverse, effectiveConstructor.name); + $constructor.$ccache = rti; + return rti; + }, + getTypeFromTypesTable(index) { + var rti, + table = init.types, + type = table[index]; + if (typeof type == "string") { + rti = H._Universe_eval(init.typeUniverse, type, false); + table[index] = rti; + return rti; + } + return type; + }, + _installSpecializedIsTest(object) { + var t1, unstarred, isFn, $name, testRti = this; + if (testRti === type$.Object) + return H._finishIsFn(testRti, object, H._isObject); + if (!H.isStrongTopType(testRti)) + if (!(testRti === type$.legacy_Object)) + t1 = false; + else + t1 = true; + else + t1 = true; + if (t1) + return H._finishIsFn(testRti, object, H._isTop); + t1 = testRti._kind; + unstarred = t1 === 6 ? testRti._primary : testRti; + if (unstarred === type$.int) + isFn = H._isInt; + else if (unstarred === type$.double || unstarred === type$.num) + isFn = H._isNum; + else if (unstarred === type$.String) + isFn = H._isString; + else + isFn = unstarred === type$.bool ? H._isBool : null; + if (isFn != null) + return H._finishIsFn(testRti, object, isFn); + if (unstarred._kind === 9) { + $name = unstarred._primary; + if (unstarred._rest.every(H.isTopType)) { + testRti._specializedTestResource = "$is" + $name; + if ($name === "List") + return H._finishIsFn(testRti, object, H._isListTestViaProperty); + return H._finishIsFn(testRti, object, H._isTestViaProperty); + } + } else if (t1 === 7) + return H._finishIsFn(testRti, object, H._generalNullableIsTestImplementation); + return H._finishIsFn(testRti, object, H._generalIsTestImplementation); + }, + _finishIsFn(testRti, object, isFn) { + testRti._is = isFn; + return testRti._is(object); + }, + _installSpecializedAsCheck(object) { + var t1, testRti = this, + asFn = H._generalAsCheckImplementation; + if (!H.isStrongTopType(testRti)) + if (!(testRti === type$.legacy_Object)) + t1 = false; + else + t1 = true; + else + t1 = true; + if (t1) + asFn = H._asTop; + else if (testRti === type$.Object) + asFn = H._asObject; + else { + t1 = H.isNullable(testRti); + if (t1) + asFn = H._generalNullableAsCheckImplementation; + } + testRti._as = asFn; + return testRti._as(object); + }, + _nullIs(testRti) { + var t1, + kind = testRti._kind; + if (!H.isStrongTopType(testRti)) + if (!(testRti === type$.legacy_Object)) + if (!(testRti === type$.legacy_Never)) + if (kind !== 7) + t1 = kind === 8 && H._nullIs(testRti._primary) || testRti === type$.Null || testRti === type$.JSNull; + else + t1 = true; + else + t1 = true; + else + t1 = true; + else + t1 = true; + return t1; + }, + _generalIsTestImplementation(object) { + var testRti = this; + if (object == null) + return H._nullIs(testRti); + return H._isSubtype(init.typeUniverse, H.instanceOrFunctionType(object, testRti), null, testRti, null); + }, + _generalNullableIsTestImplementation(object) { + if (object == null) + return true; + return this._primary._is(object); + }, + _isTestViaProperty(object) { + var tag, testRti = this; + if (object == null) + return H._nullIs(testRti); + tag = testRti._specializedTestResource; + if (object instanceof P.Object) + return !!object[tag]; + return !!J.getInterceptor$(object)[tag]; + }, + _isListTestViaProperty(object) { + var tag, testRti = this; + if (object == null) + return H._nullIs(testRti); + if (typeof object != "object") + return false; + if (Array.isArray(object)) + return true; + tag = testRti._specializedTestResource; + if (object instanceof P.Object) + return !!object[tag]; + return !!J.getInterceptor$(object)[tag]; + }, + _generalAsCheckImplementation(object) { + var t1, testRti = this; + if (object == null) { + t1 = H.isNullable(testRti); + if (t1) + return object; + } else if (testRti._is(object)) + return object; + H._failedAsCheck(object, testRti); + }, + _generalNullableAsCheckImplementation(object) { + var testRti = this; + if (object == null) + return object; + else if (testRti._is(object)) + return object; + H._failedAsCheck(object, testRti); + }, + _failedAsCheck(object, testRti) { + throw H.wrapException(H._TypeError$fromMessage(H._Error_compose(object, H.instanceOrFunctionType(object, testRti), H._rtiToString(testRti, null)))); + }, + _Error_compose(object, objectRti, checkedTypeDescription) { + var objectDescription = P.Error_safeToString(object), + objectTypeDescription = H._rtiToString(objectRti == null ? H.instanceType(object) : objectRti, null); + return objectDescription + ": type '" + objectTypeDescription + "' is not a subtype of type '" + checkedTypeDescription + "'"; + }, + _TypeError$fromMessage(message) { + return new H._TypeError("TypeError: " + message); + }, + _TypeError__TypeError$forType(object, type) { + return new H._TypeError("TypeError: " + H._Error_compose(object, null, type)); + }, + _isObject(object) { + return object != null; + }, + _asObject(object) { + if (object != null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "Object")); + }, + _isTop(object) { + return true; + }, + _asTop(object) { + return object; + }, + _isBool(object) { + return true === object || false === object; + }, + _asBool(object) { + if (true === object) + return true; + if (false === object) + return false; + throw H.wrapException(H._TypeError__TypeError$forType(object, "bool")); + }, + _asBoolS(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "bool")); + }, + _asBoolQ(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "bool?")); + }, + _asDouble(object) { + if (typeof object == "number") + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "double")); + }, + _asDoubleS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "double")); + }, + _asDoubleQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "double?")); + }, + _isInt(object) { + return typeof object == "number" && Math.floor(object) === object; + }, + _asInt(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "int")); + }, + _asIntS(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "int")); + }, + _asIntQ(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "int?")); + }, + _isNum(object) { + return typeof object == "number"; + }, + _asNum(object) { + if (typeof object == "number") + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "num")); + }, + _asNumS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "num")); + }, + _asNumQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "num?")); + }, + _isString(object) { + return typeof object == "string"; + }, + _asString(object) { + if (typeof object == "string") + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "String")); + }, + _asStringS(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "String")); + }, + _asStringQ(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw H.wrapException(H._TypeError__TypeError$forType(object, "String?")); + }, + _rtiArrayToString(array, genericContext) { + var s, sep, i; + for (s = "", sep = "", i = 0; i < array.length; ++i, sep = ", ") + s += sep + H._rtiToString(array[i], genericContext); + return s; + }, + _functionRtiToString(functionType, genericContext, bounds) { + var boundsLength, outerContextLength, offset, i, t1, t2, typeParametersText, typeSep, t3, t4, boundRti, kind, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", "; + if (bounds != null) { + boundsLength = bounds.length; + if (genericContext == null) { + genericContext = H._setArrayType([], type$.JSArray_String); + outerContextLength = null; + } else + outerContextLength = genericContext.length; + offset = genericContext.length; + for (i = boundsLength; i > 0; --i) + C.JSArray_methods.add$1(genericContext, "T" + (offset + i)); + for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) { + typeParametersText += typeSep; + t3 = genericContext.length; + t4 = t3 - 1 - i; + if (t4 < 0) + return H.ioore(genericContext, t4); + typeParametersText = C.JSString_methods.$add(typeParametersText, genericContext[t4]); + boundRti = bounds[i]; + kind = boundRti._kind; + if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1)) + if (!(boundRti === t2)) + t3 = false; + else + t3 = true; + else + t3 = true; + if (!t3) + typeParametersText += " extends " + H._rtiToString(boundRti, genericContext); + } + typeParametersText += ">"; + } else { + typeParametersText = ""; + outerContextLength = null; + } + t1 = functionType._primary; + parameters = functionType._rest; + requiredPositional = parameters._requiredPositional; + requiredPositionalLength = requiredPositional.length; + optionalPositional = parameters._optionalPositional; + optionalPositionalLength = optionalPositional.length; + named = parameters._named; + namedLength = named.length; + returnTypeText = H._rtiToString(t1, genericContext); + for (argumentsText = "", sep = "", i = 0; i < requiredPositionalLength; ++i, sep = _s2_) + argumentsText += sep + H._rtiToString(requiredPositional[i], genericContext); + if (optionalPositionalLength > 0) { + argumentsText += sep + "["; + for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_) + argumentsText += sep + H._rtiToString(optionalPositional[i], genericContext); + argumentsText += "]"; + } + if (namedLength > 0) { + argumentsText += sep + "{"; + for (sep = "", i = 0; i < namedLength; i += 3, sep = _s2_) { + argumentsText += sep; + if (named[i + 1]) + argumentsText += "required "; + argumentsText += H._rtiToString(named[i + 2], genericContext) + " " + named[i]; + } + argumentsText += "}"; + } + if (outerContextLength != null) { + genericContext.toString; + genericContext.length = outerContextLength; + } + return typeParametersText + "(" + argumentsText + ") => " + returnTypeText; + }, + _rtiToString(rti, genericContext) { + var s, questionArgument, argumentKind, $name, $arguments, t1, t2, + kind = rti._kind; + if (kind === 5) + return "erased"; + if (kind === 2) + return "dynamic"; + if (kind === 3) + return "void"; + if (kind === 1) + return "Never"; + if (kind === 4) + return "any"; + if (kind === 6) { + s = H._rtiToString(rti._primary, genericContext); + return s; + } + if (kind === 7) { + questionArgument = rti._primary; + s = H._rtiToString(questionArgument, genericContext); + argumentKind = questionArgument._kind; + return (argumentKind === 11 || argumentKind === 12 ? "(" + s + ")" : s) + "?"; + } + if (kind === 8) + return "FutureOr<" + H._rtiToString(rti._primary, genericContext) + ">"; + if (kind === 9) { + $name = H._unminifyOrTag(rti._primary); + $arguments = rti._rest; + return $arguments.length > 0 ? $name + ("<" + H._rtiArrayToString($arguments, genericContext) + ">") : $name; + } + if (kind === 11) + return H._functionRtiToString(rti, genericContext, null); + if (kind === 12) + return H._functionRtiToString(rti._primary, genericContext, rti._rest); + if (kind === 13) { + t1 = rti._primary; + t2 = genericContext.length; + t1 = t2 - 1 - t1; + if (t1 < 0 || t1 >= t2) + return H.ioore(genericContext, t1); + return genericContext[t1]; + } + return "?"; + }, + _unminifyOrTag(rawClassName) { + var preserved = init.mangledGlobalNames[rawClassName]; + if (preserved != null) + return preserved; + return rawClassName; + }, + _Universe_findRule(universe, targetType) { + var rule = universe.tR[targetType]; + for (; typeof rule == "string";) + rule = universe.tR[rule]; + return rule; + }, + _Universe_findErasedType(universe, cls) { + var $length, erased, $arguments, i, $interface, + t1 = universe.eT, + probe = t1[cls]; + if (probe == null) + return H._Universe_eval(universe, cls, false); + else if (typeof probe == "number") { + $length = probe; + erased = H._Universe__lookupTerminalRti(universe, 5, "#"); + $arguments = H._Utils_newArrayOrEmpty($length); + for (i = 0; i < $length; ++i) + $arguments[i] = erased; + $interface = H._Universe__lookupInterfaceRti(universe, cls, $arguments); + t1[cls] = $interface; + return $interface; + } else + return probe; + }, + _Universe_addRules(universe, rules) { + return H._Utils_objectAssign(universe.tR, rules); + }, + _Universe_addErasedTypes(universe, types) { + return H._Utils_objectAssign(universe.eT, types); + }, + _Universe_eval(universe, recipe, normalize) { + var rti, + t1 = universe.eC, + probe = t1.get(recipe); + if (probe != null) + return probe; + rti = H._Parser_parse(H._Parser_create(universe, null, recipe, normalize)); + t1.set(recipe, rti); + return rti; + }, + _Universe_evalInEnvironment(universe, environment, recipe) { + var probe, rti, + cache = environment._evalCache; + if (cache == null) + cache = environment._evalCache = new Map(); + probe = cache.get(recipe); + if (probe != null) + return probe; + rti = H._Parser_parse(H._Parser_create(universe, environment, recipe, true)); + cache.set(recipe, rti); + return rti; + }, + _Universe_bind(universe, environment, argumentsRti) { + var argumentsRecipe, probe, rti, + cache = environment._bindCache; + if (cache == null) + cache = environment._bindCache = new Map(); + argumentsRecipe = argumentsRti._canonicalRecipe; + probe = cache.get(argumentsRecipe); + if (probe != null) + return probe; + rti = H._Universe__lookupBindingRti(universe, environment, argumentsRti._kind === 10 ? argumentsRti._rest : [argumentsRti]); + cache.set(argumentsRecipe, rti); + return rti; + }, + _Universe__installTypeTests(universe, rti) { + rti._as = H._installSpecializedAsCheck; + rti._is = H._installSpecializedIsTest; + return rti; + }, + _Universe__lookupTerminalRti(universe, kind, key) { + var rti, t1, + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new H.Rti(null, null); + rti._kind = kind; + rti._canonicalRecipe = key; + t1 = H._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupStarRti(universe, baseType, normalize) { + var t1, + key = baseType._canonicalRecipe + "*", + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = H._Universe__createStarRti(universe, baseType, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createStarRti(universe, baseType, key, normalize) { + var baseKind, t1, rti; + if (normalize) { + baseKind = baseType._kind; + if (!H.isStrongTopType(baseType)) + t1 = baseType === type$.Null || baseType === type$.JSNull || baseKind === 7 || baseKind === 6; + else + t1 = true; + if (t1) + return baseType; + } + rti = new H.Rti(null, null); + rti._kind = 6; + rti._primary = baseType; + rti._canonicalRecipe = key; + return H._Universe__installTypeTests(universe, rti); + }, + _Universe__lookupQuestionRti(universe, baseType, normalize) { + var t1, + key = baseType._canonicalRecipe + "?", + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = H._Universe__createQuestionRti(universe, baseType, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createQuestionRti(universe, baseType, key, normalize) { + var baseKind, t1, starArgument, rti; + if (normalize) { + baseKind = baseType._kind; + if (!H.isStrongTopType(baseType)) + if (!(baseType === type$.Null || baseType === type$.JSNull)) + if (baseKind !== 7) + t1 = baseKind === 8 && H.isNullable(baseType._primary); + else + t1 = true; + else + t1 = true; + else + t1 = true; + if (t1) + return baseType; + else if (baseKind === 1 || baseType === type$.legacy_Never) + return type$.Null; + else if (baseKind === 6) { + starArgument = baseType._primary; + if (starArgument._kind === 8 && H.isNullable(starArgument._primary)) + return starArgument; + else + return H.Rti__getQuestionFromStar(universe, baseType); + } + } + rti = new H.Rti(null, null); + rti._kind = 7; + rti._primary = baseType; + rti._canonicalRecipe = key; + return H._Universe__installTypeTests(universe, rti); + }, + _Universe__lookupFutureOrRti(universe, baseType, normalize) { + var t1, + key = baseType._canonicalRecipe + "/", + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = H._Universe__createFutureOrRti(universe, baseType, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createFutureOrRti(universe, baseType, key, normalize) { + var t1, t2, rti; + if (normalize) { + t1 = baseType._kind; + if (!H.isStrongTopType(baseType)) + if (!(baseType === type$.legacy_Object)) + t2 = false; + else + t2 = true; + else + t2 = true; + if (t2 || baseType === type$.Object) + return baseType; + else if (t1 === 1) + return H._Universe__lookupInterfaceRti(universe, "Future", [baseType]); + else if (baseType === type$.Null || baseType === type$.JSNull) + return type$.nullable_Future_Null; + } + rti = new H.Rti(null, null); + rti._kind = 8; + rti._primary = baseType; + rti._canonicalRecipe = key; + return H._Universe__installTypeTests(universe, rti); + }, + _Universe__lookupGenericFunctionParameterRti(universe, index) { + var rti, t1, + key = "" + index + "^", + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new H.Rti(null, null); + rti._kind = 13; + rti._primary = index; + rti._canonicalRecipe = key; + t1 = H._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__canonicalRecipeJoin($arguments) { + var s, sep, i, + $length = $arguments.length; + for (s = "", sep = "", i = 0; i < $length; ++i, sep = ",") + s += sep + $arguments[i]._canonicalRecipe; + return s; + }, + _Universe__canonicalRecipeJoinNamed($arguments) { + var s, sep, i, t1, nameSep, s0, + $length = $arguments.length; + for (s = "", sep = "", i = 0; i < $length; i += 3, sep = ",") { + t1 = $arguments[i]; + nameSep = $arguments[i + 1] ? "!" : ":"; + s0 = $arguments[i + 2]._canonicalRecipe; + s += sep + t1 + nameSep + s0; + } + return s; + }, + _Universe__lookupInterfaceRti(universe, $name, $arguments) { + var probe, rti, t1, + s = $name; + if ($arguments.length > 0) + s += "<" + H._Universe__canonicalRecipeJoin($arguments) + ">"; + probe = universe.eC.get(s); + if (probe != null) + return probe; + rti = new H.Rti(null, null); + rti._kind = 9; + rti._primary = $name; + rti._rest = $arguments; + if ($arguments.length > 0) + rti._precomputed1 = $arguments[0]; + rti._canonicalRecipe = s; + t1 = H._Universe__installTypeTests(universe, rti); + universe.eC.set(s, t1); + return t1; + }, + _Universe__lookupBindingRti(universe, base, $arguments) { + var newBase, newArguments, key, probe, rti, t1; + if (base._kind === 10) { + newBase = base._primary; + newArguments = base._rest.concat($arguments); + } else { + newArguments = $arguments; + newBase = base; + } + key = newBase._canonicalRecipe + (";<" + H._Universe__canonicalRecipeJoin(newArguments) + ">"); + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new H.Rti(null, null); + rti._kind = 10; + rti._primary = newBase; + rti._rest = newArguments; + rti._canonicalRecipe = key; + t1 = H._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupFunctionRti(universe, returnType, parameters) { + var sep, t1, key, probe, rti, + s = returnType._canonicalRecipe, + requiredPositional = parameters._requiredPositional, + requiredPositionalLength = requiredPositional.length, + optionalPositional = parameters._optionalPositional, + optionalPositionalLength = optionalPositional.length, + named = parameters._named, + namedLength = named.length, + recipe = "(" + H._Universe__canonicalRecipeJoin(requiredPositional); + if (optionalPositionalLength > 0) { + sep = requiredPositionalLength > 0 ? "," : ""; + t1 = H._Universe__canonicalRecipeJoin(optionalPositional); + recipe += sep + "[" + t1 + "]"; + } + if (namedLength > 0) { + sep = requiredPositionalLength > 0 ? "," : ""; + t1 = H._Universe__canonicalRecipeJoinNamed(named); + recipe += sep + "{" + t1 + "}"; + } + key = s + (recipe + ")"); + probe = universe.eC.get(key); + if (probe != null) + return probe; + rti = new H.Rti(null, null); + rti._kind = 11; + rti._primary = returnType; + rti._rest = parameters; + rti._canonicalRecipe = key; + t1 = H._Universe__installTypeTests(universe, rti); + universe.eC.set(key, t1); + return t1; + }, + _Universe__lookupGenericFunctionRti(universe, baseFunctionType, bounds, normalize) { + var t1, + key = baseFunctionType._canonicalRecipe + ("<" + H._Universe__canonicalRecipeJoin(bounds) + ">"), + probe = universe.eC.get(key); + if (probe != null) + return probe; + t1 = H._Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize); + universe.eC.set(key, t1); + return t1; + }, + _Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize) { + var $length, typeArguments, count, i, bound, substitutedBase, substitutedBounds, rti; + if (normalize) { + $length = bounds.length; + typeArguments = H._Utils_newArrayOrEmpty($length); + for (count = 0, i = 0; i < $length; ++i) { + bound = bounds[i]; + if (bound._kind === 1) { + typeArguments[i] = bound; + ++count; + } + } + if (count > 0) { + substitutedBase = H._substitute(universe, baseFunctionType, typeArguments, 0); + substitutedBounds = H._substituteArray(universe, bounds, typeArguments, 0); + return H._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, bounds !== substitutedBounds); + } + } + rti = new H.Rti(null, null); + rti._kind = 12; + rti._primary = baseFunctionType; + rti._rest = bounds; + rti._canonicalRecipe = key; + return H._Universe__installTypeTests(universe, rti); + }, + _Parser_create(universe, environment, recipe, normalize) { + return {u: universe, e: environment, r: recipe, s: [], p: 0, n: normalize}; + }, + _Parser_parse(parser) { + var t2, i, ch, t3, array, head, base, parameters, optionalPositional, named, item, + source = parser.r, + t1 = parser.s; + for (t2 = source.length, i = 0; i < t2;) { + ch = source.charCodeAt(i); + if (ch >= 48 && ch <= 57) + i = H._Parser_handleDigit(i + 1, ch, source, t1); + else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36) + i = H._Parser_handleIdentifier(parser, i, source, t1, false); + else if (ch === 46) + i = H._Parser_handleIdentifier(parser, i, source, t1, true); + else { + ++i; + switch (ch) { + case 44: + break; + case 58: + t1.push(false); + break; + case 33: + t1.push(true); + break; + case 59: + t1.push(H._Parser_toType(parser.u, parser.e, t1.pop())); + break; + case 94: + t1.push(H._Universe__lookupGenericFunctionParameterRti(parser.u, t1.pop())); + break; + case 35: + t1.push(H._Universe__lookupTerminalRti(parser.u, 5, "#")); + break; + case 64: + t1.push(H._Universe__lookupTerminalRti(parser.u, 2, "@")); + break; + case 126: + t1.push(H._Universe__lookupTerminalRti(parser.u, 3, "~")); + break; + case 60: + t1.push(parser.p); + parser.p = t1.length; + break; + case 62: + t3 = parser.u; + array = t1.splice(parser.p); + H._Parser_toTypes(parser.u, parser.e, array); + parser.p = t1.pop(); + head = t1.pop(); + if (typeof head == "string") + t1.push(H._Universe__lookupInterfaceRti(t3, head, array)); + else { + base = H._Parser_toType(t3, parser.e, head); + switch (base._kind) { + case 11: + t1.push(H._Universe__lookupGenericFunctionRti(t3, base, array, parser.n)); + break; + default: + t1.push(H._Universe__lookupBindingRti(t3, base, array)); + break; + } + } + break; + case 38: + H._Parser_handleExtendedOperations(parser, t1); + break; + case 42: + t3 = parser.u; + t1.push(H._Universe__lookupStarRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parser.n)); + break; + case 63: + t3 = parser.u; + t1.push(H._Universe__lookupQuestionRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parser.n)); + break; + case 47: + t3 = parser.u; + t1.push(H._Universe__lookupFutureOrRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parser.n)); + break; + case 40: + t1.push(parser.p); + parser.p = t1.length; + break; + case 41: + t3 = parser.u; + parameters = new H._FunctionParameters(); + optionalPositional = t3.sEA; + named = t3.sEA; + head = t1.pop(); + if (typeof head == "number") + switch (head) { + case -1: + optionalPositional = t1.pop(); + break; + case -2: + named = t1.pop(); + break; + default: + t1.push(head); + break; + } + else + t1.push(head); + array = t1.splice(parser.p); + H._Parser_toTypes(parser.u, parser.e, array); + parser.p = t1.pop(); + parameters._requiredPositional = array; + parameters._optionalPositional = optionalPositional; + parameters._named = named; + t1.push(H._Universe__lookupFunctionRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parameters)); + break; + case 91: + t1.push(parser.p); + parser.p = t1.length; + break; + case 93: + array = t1.splice(parser.p); + H._Parser_toTypes(parser.u, parser.e, array); + parser.p = t1.pop(); + t1.push(array); + t1.push(-1); + break; + case 123: + t1.push(parser.p); + parser.p = t1.length; + break; + case 125: + array = t1.splice(parser.p); + H._Parser_toTypesNamed(parser.u, parser.e, array); + parser.p = t1.pop(); + t1.push(array); + t1.push(-2); + break; + default: + throw "Bad character " + ch; + } + } + } + item = t1.pop(); + return H._Parser_toType(parser.u, parser.e, item); + }, + _Parser_handleDigit(i, digit, source, stack) { + var t1, ch, + value = digit - 48; + for (t1 = source.length; i < t1; ++i) { + ch = source.charCodeAt(i); + if (!(ch >= 48 && ch <= 57)) + break; + value = value * 10 + (ch - 48); + } + stack.push(value); + return i; + }, + _Parser_handleIdentifier(parser, start, source, stack, hasPeriod) { + var t1, ch, t2, string, environment, recipe, + i = start + 1; + for (t1 = source.length; i < t1; ++i) { + ch = source.charCodeAt(i); + if (ch === 46) { + if (hasPeriod) + break; + hasPeriod = true; + } else { + if (!((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36)) + t2 = ch >= 48 && ch <= 57; + else + t2 = true; + if (!t2) + break; + } + } + string = source.substring(start, i); + if (hasPeriod) { + t1 = parser.u; + environment = parser.e; + if (environment._kind === 10) + environment = environment._primary; + recipe = H._Universe_findRule(t1, environment._primary)[string]; + if (recipe == null) + H.throwExpression('No "' + string + '" in "' + H.Rti__getCanonicalRecipe(environment) + '"'); + stack.push(H._Universe_evalInEnvironment(t1, environment, recipe)); + } else + stack.push(string); + return i; + }, + _Parser_handleExtendedOperations(parser, stack) { + var $top = stack.pop(); + if (0 === $top) { + stack.push(H._Universe__lookupTerminalRti(parser.u, 1, "0&")); + return; + } + if (1 === $top) { + stack.push(H._Universe__lookupTerminalRti(parser.u, 4, "1&")); + return; + } + throw H.wrapException(P.AssertionError$("Unexpected extended operation " + H.S($top))); + }, + _Parser_toType(universe, environment, item) { + if (typeof item == "string") + return H._Universe__lookupInterfaceRti(universe, item, universe.sEA); + else if (typeof item == "number") + return H._Parser_indexToType(universe, environment, item); + else + return item; + }, + _Parser_toTypes(universe, environment, items) { + var i, + $length = items.length; + for (i = 0; i < $length; ++i) + items[i] = H._Parser_toType(universe, environment, items[i]); + }, + _Parser_toTypesNamed(universe, environment, items) { + var i, + $length = items.length; + for (i = 2; i < $length; i += 3) + items[i] = H._Parser_toType(universe, environment, items[i]); + }, + _Parser_indexToType(universe, environment, index) { + var typeArguments, len, + kind = environment._kind; + if (kind === 10) { + if (index === 0) + return environment._primary; + typeArguments = environment._rest; + len = typeArguments.length; + if (index <= len) + return typeArguments[index - 1]; + index -= len; + environment = environment._primary; + kind = environment._kind; + } else if (index === 0) + return environment; + if (kind !== 9) + throw H.wrapException(P.AssertionError$("Indexed base must be an interface type")); + typeArguments = environment._rest; + if (index <= typeArguments.length) + return typeArguments[index - 1]; + throw H.wrapException(P.AssertionError$("Bad index " + index + " for " + environment.toString$0(0))); + }, + _isSubtype(universe, s, sEnv, t, tEnv) { + var t1, sKind, leftTypeVariable, tKind, sBounds, tBounds, sLength, i, sBound, tBound; + if (s === t) + return true; + if (!H.isStrongTopType(t)) + if (!(t === type$.legacy_Object)) + t1 = false; + else + t1 = true; + else + t1 = true; + if (t1) + return true; + sKind = s._kind; + if (sKind === 4) + return true; + if (H.isStrongTopType(s)) + return false; + if (s._kind !== 1) + t1 = false; + else + t1 = true; + if (t1) + return true; + leftTypeVariable = sKind === 13; + if (leftTypeVariable) + if (H._isSubtype(universe, sEnv[s._primary], sEnv, t, tEnv)) + return true; + tKind = t._kind; + t1 = s === type$.Null || s === type$.JSNull; + if (t1) { + if (tKind === 8) + return H._isSubtype(universe, s, sEnv, t._primary, tEnv); + return t === type$.Null || t === type$.JSNull || tKind === 7 || tKind === 6; + } + if (t === type$.Object) { + if (sKind === 8) + return H._isSubtype(universe, s._primary, sEnv, t, tEnv); + if (sKind === 6) + return H._isSubtype(universe, s._primary, sEnv, t, tEnv); + return sKind !== 7; + } + if (sKind === 6) + return H._isSubtype(universe, s._primary, sEnv, t, tEnv); + if (tKind === 6) { + t1 = H.Rti__getQuestionFromStar(universe, t); + return H._isSubtype(universe, s, sEnv, t1, tEnv); + } + if (sKind === 8) { + if (!H._isSubtype(universe, s._primary, sEnv, t, tEnv)) + return false; + return H._isSubtype(universe, H.Rti__getFutureFromFutureOr(universe, s), sEnv, t, tEnv); + } + if (sKind === 7) { + t1 = H._isSubtype(universe, type$.Null, sEnv, t, tEnv); + return t1 && H._isSubtype(universe, s._primary, sEnv, t, tEnv); + } + if (tKind === 8) { + if (H._isSubtype(universe, s, sEnv, t._primary, tEnv)) + return true; + return H._isSubtype(universe, s, sEnv, H.Rti__getFutureFromFutureOr(universe, t), tEnv); + } + if (tKind === 7) { + t1 = H._isSubtype(universe, s, sEnv, type$.Null, tEnv); + return t1 || H._isSubtype(universe, s, sEnv, t._primary, tEnv); + } + if (leftTypeVariable) + return false; + t1 = sKind !== 11; + if ((!t1 || sKind === 12) && t === type$.Function) + return true; + if (tKind === 12) { + if (s === type$.JavaScriptFunction) + return true; + if (sKind !== 12) + return false; + sBounds = s._rest; + tBounds = t._rest; + sLength = sBounds.length; + if (sLength !== tBounds.length) + return false; + sEnv = sEnv == null ? sBounds : sBounds.concat(sEnv); + tEnv = tEnv == null ? tBounds : tBounds.concat(tEnv); + for (i = 0; i < sLength; ++i) { + sBound = sBounds[i]; + tBound = tBounds[i]; + if (!H._isSubtype(universe, sBound, sEnv, tBound, tEnv) || !H._isSubtype(universe, tBound, tEnv, sBound, sEnv)) + return false; + } + return H._isFunctionSubtype(universe, s._primary, sEnv, t._primary, tEnv); + } + if (tKind === 11) { + if (s === type$.JavaScriptFunction) + return true; + if (t1) + return false; + return H._isFunctionSubtype(universe, s, sEnv, t, tEnv); + } + if (sKind === 9) { + if (tKind !== 9) + return false; + return H._isInterfaceSubtype(universe, s, sEnv, t, tEnv); + } + return false; + }, + _isFunctionSubtype(universe, s, sEnv, t, tEnv) { + var sParameters, tParameters, sRequiredPositional, tRequiredPositional, sRequiredPositionalLength, tRequiredPositionalLength, requiredPositionalDelta, sOptionalPositional, tOptionalPositional, sOptionalPositionalLength, tOptionalPositionalLength, i, t1, sNamed, tNamed, sNamedLength, tNamedLength, sIndex, tIndex, tName, sName, sIsRequired; + if (!H._isSubtype(universe, s._primary, sEnv, t._primary, tEnv)) + return false; + sParameters = s._rest; + tParameters = t._rest; + sRequiredPositional = sParameters._requiredPositional; + tRequiredPositional = tParameters._requiredPositional; + sRequiredPositionalLength = sRequiredPositional.length; + tRequiredPositionalLength = tRequiredPositional.length; + if (sRequiredPositionalLength > tRequiredPositionalLength) + return false; + requiredPositionalDelta = tRequiredPositionalLength - sRequiredPositionalLength; + sOptionalPositional = sParameters._optionalPositional; + tOptionalPositional = tParameters._optionalPositional; + sOptionalPositionalLength = sOptionalPositional.length; + tOptionalPositionalLength = tOptionalPositional.length; + if (sRequiredPositionalLength + sOptionalPositionalLength < tRequiredPositionalLength + tOptionalPositionalLength) + return false; + for (i = 0; i < sRequiredPositionalLength; ++i) { + t1 = sRequiredPositional[i]; + if (!H._isSubtype(universe, tRequiredPositional[i], tEnv, t1, sEnv)) + return false; + } + for (i = 0; i < requiredPositionalDelta; ++i) { + t1 = sOptionalPositional[i]; + if (!H._isSubtype(universe, tRequiredPositional[sRequiredPositionalLength + i], tEnv, t1, sEnv)) + return false; + } + for (i = 0; i < tOptionalPositionalLength; ++i) { + t1 = sOptionalPositional[requiredPositionalDelta + i]; + if (!H._isSubtype(universe, tOptionalPositional[i], tEnv, t1, sEnv)) + return false; + } + sNamed = sParameters._named; + tNamed = tParameters._named; + sNamedLength = sNamed.length; + tNamedLength = tNamed.length; + for (sIndex = 0, tIndex = 0; tIndex < tNamedLength; tIndex += 3) { + tName = tNamed[tIndex]; + for (; true;) { + if (sIndex >= sNamedLength) + return false; + sName = sNamed[sIndex]; + sIndex += 3; + if (tName < sName) + return false; + sIsRequired = sNamed[sIndex - 2]; + if (sName < tName) { + if (sIsRequired) + return false; + continue; + } + t1 = tNamed[tIndex + 1]; + if (sIsRequired && !t1) + return false; + t1 = sNamed[sIndex - 1]; + if (!H._isSubtype(universe, tNamed[tIndex + 2], tEnv, t1, sEnv)) + return false; + break; + } + } + for (; sIndex < sNamedLength;) { + if (sNamed[sIndex + 1]) + return false; + sIndex += 3; + } + return true; + }, + _isInterfaceSubtype(universe, s, sEnv, t, tEnv) { + var rule, recipes, $length, supertypeArgs, i, t1, t2, + sName = s._primary, + tName = t._primary; + for (; sName !== tName;) { + rule = universe.tR[sName]; + if (rule == null) + return false; + if (typeof rule == "string") { + sName = rule; + continue; + } + recipes = rule[tName]; + if (recipes == null) + return false; + $length = recipes.length; + supertypeArgs = $length > 0 ? new Array($length) : init.typeUniverse.sEA; + for (i = 0; i < $length; ++i) + supertypeArgs[i] = H._Universe_evalInEnvironment(universe, s, recipes[i]); + return H._areArgumentsSubtypes(universe, supertypeArgs, null, sEnv, t._rest, tEnv); + } + t1 = s._rest; + t2 = t._rest; + return H._areArgumentsSubtypes(universe, t1, null, sEnv, t2, tEnv); + }, + _areArgumentsSubtypes(universe, sArgs, sVariances, sEnv, tArgs, tEnv) { + var i, t1, t2, + $length = sArgs.length; + for (i = 0; i < $length; ++i) { + t1 = sArgs[i]; + t2 = tArgs[i]; + if (!H._isSubtype(universe, t1, sEnv, t2, tEnv)) + return false; + } + return true; + }, + isNullable(t) { + var t1, + kind = t._kind; + if (!(t === type$.Null || t === type$.JSNull)) + if (!H.isStrongTopType(t)) + if (kind !== 7) + if (!(kind === 6 && H.isNullable(t._primary))) + t1 = kind === 8 && H.isNullable(t._primary); + else + t1 = true; + else + t1 = true; + else + t1 = true; + else + t1 = true; + return t1; + }, + isTopType(t) { + var t1; + if (!H.isStrongTopType(t)) + if (!(t === type$.legacy_Object)) + t1 = false; + else + t1 = true; + else + t1 = true; + return t1; + }, + isStrongTopType(t) { + var kind = t._kind; + return kind === 2 || kind === 3 || kind === 4 || kind === 5 || t === type$.nullable_Object; + }, + _Utils_objectAssign(o, other) { + var i, key, + keys = Object.keys(other), + $length = keys.length; + for (i = 0; i < $length; ++i) { + key = keys[i]; + o[key] = other[key]; + } + }, + _Utils_newArrayOrEmpty($length) { + return $length > 0 ? new Array($length) : init.typeUniverse.sEA; + }, + Rti: function Rti(t0, t1) { + var _ = this; + _._as = t0; + _._is = t1; + _._cachedRuntimeType = _._specializedTestResource = _._precomputed1 = null; + _._kind = 0; + _._canonicalRecipe = _._bindCache = _._evalCache = _._rest = _._primary = null; + }, + _FunctionParameters: function _FunctionParameters() { + this._named = this._optionalPositional = this._requiredPositional = null; + }, + _Error: function _Error() { + }, + _TypeError: function _TypeError(t0) { + this.__rti$_message = t0; + }, + printString(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); + }, + throwLateFieldADI(fieldName) { + return H.throwExpression(new H.LateError("Field '" + fieldName + "' has been assigned during initialization.")); + } + }, + J = { + makeDispatchRecord(interceptor, proto, extension, indexability) { + return {i: interceptor, p: proto, e: extension, x: indexability}; + }, + getNativeInterceptor(object) { + var proto, objectProto, $constructor, interceptor, t1, + record = object[init.dispatchPropertyName]; + if (record == null) + if ($.initNativeDispatchFlag == null) { + H.initNativeDispatch(); + record = object[init.dispatchPropertyName]; + } + if (record != null) { + proto = record.p; + if (false === proto) + return record.i; + if (true === proto) + return object; + objectProto = Object.getPrototypeOf(object); + if (proto === objectProto) + return record.i; + if (record.e === objectProto) + throw H.wrapException(P.UnimplementedError$("Return interceptor for " + H.S(proto(object, record)))); + } + $constructor = object.constructor; + if ($constructor == null) + interceptor = null; + else { + t1 = $._JS_INTEROP_INTERCEPTOR_TAG; + if (t1 == null) + t1 = $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js"); + interceptor = $constructor[t1]; + } + if (interceptor != null) + return interceptor; + interceptor = H.lookupAndCacheInterceptor(object); + if (interceptor != null) + return interceptor; + if (typeof object == "function") + return C.JavaScriptFunction_methods; + proto = Object.getPrototypeOf(object); + if (proto == null) + return C.PlainJavaScriptObject_methods; + if (proto === Object.prototype) + return C.PlainJavaScriptObject_methods; + if (typeof $constructor == "function") { + t1 = $._JS_INTEROP_INTERCEPTOR_TAG; + if (t1 == null) + t1 = $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js"); + Object.defineProperty($constructor, t1, {value: C.UnknownJavaScriptObject_methods, enumerable: false, writable: true, configurable: true}); + return C.UnknownJavaScriptObject_methods; + } + return C.UnknownJavaScriptObject_methods; + }, + JSArray_markFixedList(list, $T) { + list.fixed$length = Array; + return list; + }, + getInterceptor$(receiver) { + if (typeof receiver == "number") { + if (Math.floor(receiver) == receiver) + return J.JSInt.prototype; + return J.JSNumNotInt.prototype; + } + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return J.JSNull.prototype; + if (typeof receiver == "boolean") + return J.JSBool.prototype; + if (receiver.constructor == Array) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + return receiver; + } + if (receiver instanceof P.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$asx(receiver) { + if (typeof receiver == "string") + return J.JSString.prototype; + if (receiver == null) + return receiver; + if (receiver.constructor == Array) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + return receiver; + } + if (receiver instanceof P.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + getInterceptor$ax(receiver) { + if (receiver == null) + return receiver; + if (receiver.constructor == Array) + return J.JSArray.prototype; + if (typeof receiver != "object") { + if (typeof receiver == "function") + return J.JavaScriptFunction.prototype; + return receiver; + } + if (receiver instanceof P.Object) + return receiver; + return J.getNativeInterceptor(receiver); + }, + get$iterator$ax(receiver) { + return J.getInterceptor$ax(receiver).get$iterator(receiver); + }, + get$length$asx(receiver) { + return J.getInterceptor$asx(receiver).get$length(receiver); + }, + elementAt$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); + }, + toString$0$(receiver) { + return J.getInterceptor$(receiver).toString$0(receiver); + }, + Interceptor: function Interceptor() { + }, + JSBool: function JSBool() { + }, + JSNull: function JSNull() { + }, + JavaScriptObject: function JavaScriptObject() { + }, + PlainJavaScriptObject: function PlainJavaScriptObject() { + }, + UnknownJavaScriptObject: function UnknownJavaScriptObject() { + }, + JavaScriptFunction: function JavaScriptFunction() { + }, + JSArray: function JSArray(t0) { + this.$ti = t0; + }, + JSUnmodifiableArray: function JSUnmodifiableArray(t0) { + this.$ti = t0; + }, + ArrayIterator: function ArrayIterator(t0, t1, t2) { + var _ = this; + _._iterable = t0; + _._length = t1; + _._index = 0; + _._current = null; + _.$ti = t2; + }, + JSNumber: function JSNumber() { + }, + JSInt: function JSInt() { + }, + JSNumNotInt: function JSNumNotInt() { + }, + JSString: function JSString() { + } + }, + K = { + Bolt12Decoder$() { + var t1 = new K.Bolt12Decoder(); + t1.Bolt12Decoder$0(); + return t1; + }, + Bolt12Decoder: function Bolt12Decoder() { + }, + Bolt12Decoder_closure: function Bolt12Decoder_closure() { + } + }, + M = {Bolt12Encoder: function Bolt12Encoder() { + this.__Bolt12Encoder__bech32codec = null; + }}, + N = {Bolt12: function Bolt12(t0) { + this.hrp = t0; + this.__Bolt12__encoder = null; + }}, + O = { + _polymod(values) { + var t1 = {}; + t1.chk = 1; + C.JSArray_methods.forEach$1(values, new O._polymod_closure(t1)); + return t1.chk; + }, + _hrpExpand(hrp) { + var t3, + t1 = type$.CodeUnits, + t2 = t1._eval$1("int(ListMixin.E)"); + t1 = t1._eval$1("MappedListIterable"); + t3 = t1._eval$1("ListIterable.E"); + return C.JSArray_methods.$add(C.JSArray_methods.$add(P.List_List$of(new H.MappedListIterable(new H.CodeUnits(hrp), t2._as(new O._hrpExpand_closure()), t1), true, t3), H._setArrayType([0], type$.JSArray_int)), P.List_List$of(new H.MappedListIterable(new H.CodeUnits(hrp), t2._as(new O._hrpExpand_closure0()), t1), true, t3)); + }, + _createChecksum(hrp, data) { + var i, + t1 = type$.JSArray_int, + polymod = (O._polymod(C.JSArray_methods.$add(C.JSArray_methods.$add(O._hrpExpand(hrp), data), H._setArrayType([0, 0, 0, 0, 0, 0], t1))) ^ 1) >>> 0, + result = H._setArrayType([0, 0, 0, 0, 0, 0], t1); + for (i = 0; i < 6; ++i) + C.JSArray_methods.$indexSet(result, i, C.JSInt_methods._shrReceiverPositive$1(polymod, 5 * (5 - i)) & 31); + return result; + }, + Bech32Codec: function Bech32Codec() { + }, + Bech32Encoder: function Bech32Encoder() { + }, + Bech32Encoder_convert_closure: function Bech32Encoder_convert_closure() { + }, + Bech32Validations: function Bech32Validations() { + }, + Bech32Validations_hasOutOfBoundsChars_closure: function Bech32Validations_hasOutOfBoundsChars_closure() { + }, + Bech32Validations_hasOutOfRangeHrpCharacters_closure: function Bech32Validations_hasOutOfRangeHrpCharacters_closure() { + }, + Bech32: function Bech32(t0, t1) { + this.hrp = t0; + this.data = t1; + }, + _polymod_closure: function _polymod_closure(t0) { + this._box_0 = t0; + }, + _hrpExpand_closure: function _hrpExpand_closure() { + }, + _hrpExpand_closure0: function _hrpExpand_closure0() { + }, + _Bech32Encoder_Converter_Bech32Validations: function _Bech32Encoder_Converter_Bech32Validations() { + } + }, + P = {StreamTransformerBase: function StreamTransformerBase() { + }, + LinkedHashMap_LinkedHashMap$_empty($K, $V) { + return new H.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + }, + IterableBase_iterableToShortString(iterable, leftDelimiter, rightDelimiter) { + var parts, t1; + if (P._isToStringVisiting(iterable)) { + if (leftDelimiter === "(" && rightDelimiter === ")") + return "(...)"; + return leftDelimiter + "..." + rightDelimiter; + } + parts = H._setArrayType([], type$.JSArray_String); + C.JSArray_methods.add$1($._toStringVisiting, iterable); + try { + P._iterablePartsToStrings(iterable, parts); + } finally { + if (0 >= $._toStringVisiting.length) + return H.ioore($._toStringVisiting, -1); + $._toStringVisiting.pop(); + } + t1 = P.StringBuffer__writeAll(leftDelimiter, type$.Iterable_dynamic._as(parts), ", ") + rightDelimiter; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + IterableBase_iterableToFullString(iterable, leftDelimiter, rightDelimiter) { + var buffer, t1; + if (P._isToStringVisiting(iterable)) + return leftDelimiter + "..." + rightDelimiter; + buffer = new P.StringBuffer(leftDelimiter); + C.JSArray_methods.add$1($._toStringVisiting, iterable); + try { + t1 = buffer; + t1._contents = P.StringBuffer__writeAll(t1._contents, iterable, ", "); + } finally { + if (0 >= $._toStringVisiting.length) + return H.ioore($._toStringVisiting, -1); + $._toStringVisiting.pop(); + } + buffer._contents += rightDelimiter; + t1 = buffer._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _isToStringVisiting(o) { + var t1, i; + for (t1 = $._toStringVisiting.length, i = 0; i < t1; ++i) + if (o === $._toStringVisiting[i]) + return true; + return false; + }, + _iterablePartsToStrings(iterable, parts) { + var next, ultimateString, penultimateString, penultimate, ultimate, ultimate0, elision, + it = iterable.get$iterator(iterable), + $length = 0, count = 0; + while (true) { + if (!($length < 80 || count < 3)) + break; + if (!it.moveNext$0()) + return; + next = H.S(it.get$current()); + C.JSArray_methods.add$1(parts, next); + $length += next.length + 2; + ++count; + } + if (!it.moveNext$0()) { + if (count <= 5) + return; + if (0 >= parts.length) + return H.ioore(parts, -1); + ultimateString = parts.pop(); + if (0 >= parts.length) + return H.ioore(parts, -1); + penultimateString = parts.pop(); + } else { + penultimate = it.get$current(); + ++count; + if (!it.moveNext$0()) { + if (count <= 4) { + C.JSArray_methods.add$1(parts, H.S(penultimate)); + return; + } + ultimateString = H.S(penultimate); + if (0 >= parts.length) + return H.ioore(parts, -1); + penultimateString = parts.pop(); + $length += ultimateString.length + 2; + } else { + ultimate = it.get$current(); + ++count; + for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) { + ultimate0 = it.get$current(); + ++count; + if (count > 100) { + while (true) { + if (!($length > 75 && count > 3)) + break; + if (0 >= parts.length) + return H.ioore(parts, -1); + $length -= parts.pop().length + 2; + --count; + } + C.JSArray_methods.add$1(parts, "..."); + return; + } + } + penultimateString = H.S(penultimate); + ultimateString = H.S(ultimate); + $length += ultimateString.length + penultimateString.length + 4; + } + } + if (count > parts.length + 2) { + $length += 5; + elision = "..."; + } else + elision = null; + while (true) { + if (!($length > 80 && parts.length > 3)) + break; + if (0 >= parts.length) + return H.ioore(parts, -1); + $length -= parts.pop().length + 2; + if (elision == null) { + $length += 5; + elision = "..."; + } + } + if (elision != null) + C.JSArray_methods.add$1(parts, elision); + C.JSArray_methods.add$1(parts, penultimateString); + C.JSArray_methods.add$1(parts, ultimateString); + }, + MapBase_mapToString(m) { + var result, t1 = {}; + if (P._isToStringVisiting(m)) + return "{...}"; + result = new P.StringBuffer(""); + try { + C.JSArray_methods.add$1($._toStringVisiting, m); + result._contents += "{"; + t1.first = true; + m.forEach$1(0, new P.MapBase_mapToString_closure(t1, result)); + result._contents += "}"; + } finally { + if (0 >= $._toStringVisiting.length) + return H.ioore($._toStringVisiting, -1); + $._toStringVisiting.pop(); + } + t1 = result._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + ListBase: function ListBase() { + }, + ListMixin: function ListMixin() { + }, + MapBase: function MapBase() { + }, + MapBase_mapToString_closure: function MapBase_mapToString_closure(t0, t1) { + this._box_0 = t0; + this.result = t1; + }, + MapMixin: function MapMixin() { + }, + _ListBase_Object_ListMixin: function _ListBase_Object_ListMixin() { + }, + _isLeadSurrogate(codeUnit) { + codeUnit.$and(0, 64512); + return false; + }, + _isTailSurrogate(codeUnit) { + codeUnit.$and(0, 64512); + return false; + }, + _combineSurrogatePair(lead, tail) { + return C.JSNumber_methods.$or(C.JSInt_methods.$add(65536, lead.$and(0, 1023).$shl(0, 10)), tail.$and(0, 1023)); + }, + Codec: function Codec() { + }, + Converter: function Converter() { + }, + Encoding: function Encoding() { + }, + Utf8Codec: function Utf8Codec() { + }, + Utf8Encoder: function Utf8Encoder() { + }, + _Utf8Encoder: function _Utf8Encoder(t0) { + this._bufferIndex = 0; + this._buffer = t0; + }, + Error__objectToString(object) { + if (object instanceof H.Closure) + return object.toString$0(0); + return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; + }, + List_List$of(elements, growable, $E) { + var t1 = P.List_List$_of(elements, $E); + return t1; + }, + List_List$_of(elements, $E) { + var list, t1; + if (Array.isArray(elements)) + return H._setArrayType(elements.slice(0), $E._eval$1("JSArray<0>")); + list = H._setArrayType([], $E._eval$1("JSArray<0>")); + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + C.JSArray_methods.add$1(list, t1.get$current()); + return list; + }, + StringBuffer__writeAll(string, objects, separator) { + var iterator = J.get$iterator$ax(objects); + if (!iterator.moveNext$0()) + return string; + if (separator.length === 0) { + do + string += H.S(iterator.get$current()); + while (iterator.moveNext$0()); + } else { + string += H.S(iterator.get$current()); + for (; iterator.moveNext$0();) + string = string + separator + H.S(iterator.get$current()); + } + return string; + }, + Error_safeToString(object) { + if (typeof object == "number" || H._isBool(object) || object == null) + return J.toString$0$(object); + if (typeof object == "string") + return JSON.stringify(object); + return P.Error__objectToString(object); + }, + AssertionError$(message) { + return new P.AssertionError(message); + }, + ArgumentError$(message) { + return new P.ArgumentError(false, null, null, message); + }, + RangeError$range(invalidValue, minValue, maxValue, $name, message) { + return new P.RangeError(minValue, maxValue, true, invalidValue, $name, "Invalid value"); + }, + RangeError_checkValidRange(start, end, $length) { + if (start > $length) + throw H.wrapException(P.RangeError$range(start, 0, $length, "start", null)); + if (end != null) { + if (start > end || end > $length) + throw H.wrapException(P.RangeError$range(end, start, $length, "end", null)); + return end; + } + return $length; + }, + RangeError_checkNotNegative(value, $name) { + if (value < 0) + throw H.wrapException(P.RangeError$range(value, 0, null, $name, null)); + return value; + }, + IndexError$(invalidValue, indexable, $name, message, $length) { + var t1 = $length == null ? J.get$length$asx(indexable) : $length; + return new P.IndexError(t1, true, invalidValue, $name, "Index out of range"); + }, + UnsupportedError$(message) { + return new P.UnsupportedError(message); + }, + UnimplementedError$(message) { + return new P.UnimplementedError(message); + }, + ConcurrentModificationError$(modifiedObject) { + return new P.ConcurrentModificationError(modifiedObject); + }, + print(object) { + H.printString(object); + }, + Error: function Error() { + }, + AssertionError: function AssertionError(t0) { + this.message = t0; + }, + NullThrownError: function NullThrownError() { + }, + ArgumentError: function ArgumentError(t0, t1, t2, t3) { + var _ = this; + _._hasValue = t0; + _.invalidValue = t1; + _.name = t2; + _.message = t3; + }, + RangeError: function RangeError(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.start = t0; + _.end = t1; + _._hasValue = t2; + _.invalidValue = t3; + _.name = t4; + _.message = t5; + }, + IndexError: function IndexError(t0, t1, t2, t3, t4) { + var _ = this; + _.length = t0; + _._hasValue = t1; + _.invalidValue = t2; + _.name = t3; + _.message = t4; + }, + UnsupportedError: function UnsupportedError(t0) { + this.message = t0; + }, + UnimplementedError: function UnimplementedError(t0) { + this.message = t0; + }, + ConcurrentModificationError: function ConcurrentModificationError(t0) { + this.modifiedObject = t0; + }, + CyclicInitializationError: function CyclicInitializationError(t0) { + this.variableName = t0; + }, + Iterable: function Iterable() { + }, + Null: function Null() { + }, + Object: function Object() { + }, + StringBuffer: function StringBuffer(t0) { + this._contents = t0; + } + }, + T = {TooShortHrp: function TooShortHrp() { + }, TooLong: function TooLong(t0) { + this.length = t0; + }, OutOfRangeHrpCharacters: function OutOfRangeHrpCharacters(t0) { + this.hpr = t0; + }, MixedCase: function MixedCase(t0) { + this.hpr = t0; + }, OutOfBoundChars: function OutOfBoundChars(t0) { + this.char = t0; + }}, + W = {DomException: function DomException() { + }}, + Z = {HashFunction: function HashFunction() { + this.__HashFunction__hasher = null; + }}; + var holders = [C, F, H, J, K, M, N, O, P, T, W, Z]; + hunkHelpers.setFunctionNamesIfNecessary(holders); + var $ = {}; + H.JS_CONST.prototype = {}; + J.Interceptor.prototype = { + toString$0(receiver) { + return "Instance of '" + H.Primitives_objectTypeName(receiver) + "'"; + } + }; + J.JSBool.prototype = { + toString$0(receiver) { + return String(receiver); + }, + $isbool: 1 + }; + J.JSNull.prototype = { + toString$0(receiver) { + return "null"; + } + }; + J.JavaScriptObject.prototype = { + toString$0(receiver) { + return String(receiver); + } + }; + J.PlainJavaScriptObject.prototype = {}; + J.UnknownJavaScriptObject.prototype = {}; + J.JavaScriptFunction.prototype = { + toString$0(receiver) { + var dartClosure = receiver[$.$get$DART_CLOSURE_PROPERTY_NAME()]; + if (dartClosure == null) + return this.super$JavaScriptObject$toString(receiver); + return "JavaScript function for " + J.toString$0$(dartClosure); + } + }; + J.JSArray.prototype = { + add$1(receiver, value) { + H._arrayInstanceType(receiver)._precomputed1._as(value); + if (!!receiver.fixed$length) + H.throwExpression(P.UnsupportedError$("add")); + receiver.push(value); + }, + addAll$1(receiver, collection) { + H._arrayInstanceType(receiver)._eval$1("Iterable<1>")._as(collection); + if (!!receiver.fixed$length) + H.throwExpression(P.UnsupportedError$("addAll")); + this._addAllFromArray$1(receiver, collection); + return; + }, + _addAllFromArray$1(receiver, array) { + var len, i; + type$.JSArray_dynamic._as(array); + len = array.length; + if (len === 0) + return; + if (receiver === array) + throw H.wrapException(P.ConcurrentModificationError$(receiver)); + for (i = 0; i < len; ++i) + receiver.push(array[i]); + }, + forEach$1(receiver, f) { + var end, i; + H._arrayInstanceType(receiver)._eval$1("~(1)")._as(f); + end = receiver.length; + for (i = 0; i < end; ++i) { + f.call$1(receiver[i]); + if (receiver.length !== end) + throw H.wrapException(P.ConcurrentModificationError$(receiver)); + } + }, + elementAt$1(receiver, index) { + if (index >= receiver.length) + return H.ioore(receiver, index); + return receiver[index]; + }, + any$1(receiver, test) { + var end, i; + H._arrayInstanceType(receiver)._eval$1("bool(1)")._as(test); + end = receiver.length; + for (i = 0; i < end; ++i) { + if (H.boolConversionCheck(test.call$1(receiver[i]))) + return true; + if (receiver.length !== end) + throw H.wrapException(P.ConcurrentModificationError$(receiver)); + } + return false; + }, + toString$0(receiver) { + return P.IterableBase_iterableToFullString(receiver, "[", "]"); + }, + get$iterator(receiver) { + return new J.ArrayIterator(receiver, receiver.length, H._arrayInstanceType(receiver)._eval$1("ArrayIterator<1>")); + }, + get$length(receiver) { + return receiver.length; + }, + $indexSet(receiver, index, value) { + H._arrayInstanceType(receiver)._precomputed1._as(value); + if (!!receiver.immutable$list) + H.throwExpression(P.UnsupportedError$("indexed set")); + if (index >= receiver.length || false) + throw H.wrapException(H.diagnoseIndexError(receiver, index)); + receiver[index] = value; + }, + $add(receiver, other) { + var t1 = H._arrayInstanceType(receiver); + t1._eval$1("List<1>")._as(other); + t1 = P.List_List$of(receiver, true, t1._precomputed1); + this.addAll$1(t1, other); + return t1; + }, + $isIterable: 1, + $isList: 1 + }; + J.JSUnmodifiableArray.prototype = {}; + J.ArrayIterator.prototype = { + get$current() { + return this.$ti._precomputed1._as(this._current); + }, + moveNext$0() { + var t2, _this = this, + t1 = _this._iterable, + $length = t1.length; + if (_this._length !== $length) + throw H.wrapException(H.throwConcurrentModificationError(t1)); + t2 = _this._index; + if (t2 >= $length) { + _this.set$_current(null); + return false; + } + _this.set$_current(t1[t2]); + ++_this._index; + return true; + }, + set$_current(_current) { + this._current = this.$ti._eval$1("1?")._as(_current); + } + }; + J.JSNumber.prototype = { + toString$0(receiver) { + if (receiver === 0 && 1 / receiver < 0) + return "-0.0"; + else + return "" + receiver; + }, + $add(receiver, other) { + return receiver + other; + }, + _shrOtherPositive$1(receiver, other) { + var t1; + if (receiver > 0) + t1 = this._shrBothPositive$1(receiver, other); + else { + t1 = other > 31 ? 31 : other; + t1 = receiver >> t1 >>> 0; + } + return t1; + }, + _shrReceiverPositive$1(receiver, other) { + if (0 > other) + throw H.wrapException(H.argumentErrorValue(other)); + return this._shrBothPositive$1(receiver, other); + }, + _shrBothPositive$1(receiver, other) { + return other > 31 ? 0 : receiver >>> other; + }, + $or(receiver, other) { + return (receiver | other) >>> 0; + }, + $isnum: 1 + }; + J.JSInt.prototype = {$isint: 1}; + J.JSNumNotInt.prototype = {}; + J.JSString.prototype = { + codeUnitAt$1(receiver, index) { + if (index < 0) + throw H.wrapException(H.diagnoseIndexError(receiver, index)); + if (index >= receiver.length) + H.throwExpression(H.diagnoseIndexError(receiver, index)); + return receiver.charCodeAt(index); + }, + $add(receiver, other) { + return receiver + other; + }, + toString$0(receiver) { + return receiver; + }, + get$length(receiver) { + return receiver.length; + }, + $isString: 1 + }; + H.LateError.prototype = { + toString$0(_) { + var t1 = "LateInitializationError: " + this._message; + return t1; + } + }; + H.CodeUnits.prototype = { + get$length(_) { + return this._string.length; + }, + $index(_, i) { + return C.JSString_methods.codeUnitAt$1(this._string, i); + } + }; + H.EfficientLengthIterable.prototype = {}; + H.ListIterable.prototype = { + get$iterator(_) { + var _this = this; + return new H.ListIterator(_this, _this.get$length(_this), H._instanceType(_this)._eval$1("ListIterator")); + }, + join$0(_) { + var i, t1, _this = this, + $length = _this.get$length(_this); + for (i = 0, t1 = ""; i < $length; ++i) { + t1 += H.S(_this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw H.wrapException(P.ConcurrentModificationError$(_this)); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + H.ListIterator.prototype = { + get$current() { + return this.$ti._precomputed1._as(this.__internal$_current); + }, + moveNext$0() { + var t3, _this = this, + t1 = _this.__internal$_iterable, + t2 = J.getInterceptor$asx(t1), + $length = t2.get$length(t1); + if (_this.__internal$_length !== $length) + throw H.wrapException(P.ConcurrentModificationError$(t1)); + t3 = _this.__internal$_index; + if (t3 >= $length) { + _this.set$__internal$_current(null); + return false; + } + _this.set$__internal$_current(t2.elementAt$1(t1, t3)); + ++_this.__internal$_index; + return true; + }, + set$__internal$_current(_current) { + this.__internal$_current = this.$ti._eval$1("1?")._as(_current); + } + }; + H.MappedListIterable.prototype = { + get$length(_) { + return J.get$length$asx(this._source); + }, + elementAt$1(_, index) { + return this._f.call$1(J.elementAt$1$ax(this._source, index)); + } + }; + H.FixedLengthListMixin.prototype = {}; + H.UnmodifiableListMixin.prototype = {}; + H.UnmodifiableListBase.prototype = {}; + H.Closure.prototype = { + toString$0(_) { + var $constructor = this.constructor, + $name = $constructor == null ? null : $constructor.name; + return "Closure '" + H.unminifyOrTag($name == null ? "unknown" : $name) + "'"; + }, + get$$call() { + return this; + }, + "call*": "call$1", + $requiredArgCount: 1, + $defaultValues: null + }; + H.Closure0Args.prototype = {"call*": "call$0", $requiredArgCount: 0}; + H.Closure2Args.prototype = {"call*": "call$2", $requiredArgCount: 2}; + H.TearOffClosure.prototype = {}; + H.StaticClosure.prototype = { + toString$0(_) { + var $name = this.$static_name; + if ($name == null) + return "Closure of unknown static method"; + return "Closure '" + H.unminifyOrTag($name) + "'"; + } + }; + H.BoundClosure.prototype = { + toString$0(_) { + return "Closure '" + this.$_name + "' of " + ("Instance of '" + H.Primitives_objectTypeName(type$.Object._as(this._receiver)) + "'"); + } + }; + H.RuntimeError.prototype = { + toString$0(_) { + return "RuntimeError: " + this.message; + } + }; + H._AssertionError.prototype = { + toString$0(_) { + return "Assertion failed: " + P.Error_safeToString(this.message); + } + }; + H.JsLinkedHashMap.prototype = { + get$length(_) { + return this.__js_helper$_length; + }, + forEach$1(_, action) { + var cell, modifications, _this = this; + H._instanceType(_this)._eval$1("~(1,2)")._as(action); + cell = _this._first; + modifications = _this._modifications; + for (; cell != null;) { + action.call$2(cell.hashMapCellKey, cell.hashMapCellValue); + if (modifications !== _this._modifications) + throw H.wrapException(P.ConcurrentModificationError$(_this)); + cell = cell._next; + } + }, + toString$0(_) { + return P.MapBase_mapToString(this); + } + }; + H.initHooks_closure.prototype = { + call$1(o) { + return this.getTag(o); + }, + $signature: 2 + }; + H.initHooks_closure0.prototype = { + call$2(o, tag) { + return this.getUnknownTag(o, tag); + }, + $signature: 3 + }; + H.initHooks_closure1.prototype = { + call$1(tag) { + return this.prototypeForTag(H._asString(tag)); + }, + $signature: 4 + }; + H.NativeTypedData.prototype = {}; + H.NativeTypedArray.prototype = { + get$length(receiver) { + return receiver.length; + }, + $isJavaScriptIndexingBehavior: 1 + }; + H.NativeTypedArrayOfInt.prototype = { + $indexSet(receiver, index, value) { + H._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + $isIterable: 1, + $isList: 1 + }; + H.NativeUint8List.prototype = { + get$length(receiver) { + return receiver.length; + }, + $index(receiver, index) { + H._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isUint8List: 1 + }; + H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin.prototype = {}; + H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin.prototype = {}; + H.Rti.prototype = { + _eval$1(recipe) { + return H._Universe_evalInEnvironment(init.typeUniverse, this, recipe); + }, + _bind$1(typeOrTuple) { + return H._Universe_bind(init.typeUniverse, this, typeOrTuple); + } + }; + H._FunctionParameters.prototype = {}; + H._Error.prototype = { + toString$0(_) { + return this.__rti$_message; + } + }; + H._TypeError.prototype = {}; + P.StreamTransformerBase.prototype = {}; + P.ListBase.prototype = {$isIterable: 1, $isList: 1}; + P.ListMixin.prototype = { + get$iterator(receiver) { + return new H.ListIterator(receiver, this.get$length(receiver), H.instanceType(receiver)._eval$1("ListIterator")); + }, + elementAt$1(receiver, index) { + return this.$index(receiver, index); + }, + any$1(receiver, test) { + var $length, i; + H.instanceType(receiver)._eval$1("bool(ListMixin.E)")._as(test); + $length = this.get$length(receiver); + for (i = 0; i < $length; ++i) { + if (H.boolConversionCheck(test.call$1(this.$index(receiver, i)))) + return true; + if ($length !== this.get$length(receiver)) + throw H.wrapException(P.ConcurrentModificationError$(receiver)); + } + return false; + }, + toString$0(receiver) { + return P.IterableBase_iterableToFullString(receiver, "[", "]"); + } + }; + P.MapBase.prototype = {}; + P.MapBase_mapToString_closure.prototype = { + call$2(k, v) { + var t2, + t1 = this._box_0; + if (!t1.first) + this.result._contents += ", "; + t1.first = false; + t1 = this.result; + t2 = t1._contents += H.S(k); + t1._contents = t2 + ": "; + t1._contents += H.S(v); + }, + $signature: 5 + }; + P.MapMixin.prototype = { + get$length(_) { + return this.__js_helper$_length; + }, + toString$0(_) { + return P.MapBase_mapToString(this); + }, + $isMap: 1 + }; + P._ListBase_Object_ListMixin.prototype = {}; + P.Codec.prototype = {}; + P.Converter.prototype = {}; + P.Encoding.prototype = {}; + P.Utf8Codec.prototype = { + get$encoder() { + return C.C_Utf8Encoder; + } + }; + P.Utf8Encoder.prototype = { + convert$1(string) { + var t1, t2, encoder, + end = P.RangeError_checkValidRange(0, null, string.get$length(string)), + $length = end - 0; + if ($length === 0) + return new Uint8Array(0); + t1 = $length * 3; + t2 = new Uint8Array(t1); + encoder = new P._Utf8Encoder(t2); + if (encoder._fillBuffer$3(string, 0, end) !== end) { + string.codeUnitAt$1(0, end - 1); + encoder._writeReplacementCharacter$0(); + } + return new Uint8Array(t2.subarray(0, H._checkValidRange(0, encoder._bufferIndex, t1))); + } + }; + P._Utf8Encoder.prototype = { + _writeReplacementCharacter$0() { + var _this = this, + t1 = _this._buffer, + t2 = _this._bufferIndex, + t3 = _this._bufferIndex = t2 + 1, + t4 = t1.length; + if (t2 >= t4) + return H.ioore(t1, t2); + t1[t2] = 239; + t2 = _this._bufferIndex = t3 + 1; + if (t3 >= t4) + return H.ioore(t1, t3); + t1[t3] = 191; + _this._bufferIndex = t2 + 1; + if (t2 >= t4) + return H.ioore(t1, t2); + t1[t2] = 189; + }, + _writeSurrogate$2(leadingSurrogate, nextCodeUnit) { + if (P._isTailSurrogate(nextCodeUnit)) + P._combineSurrogatePair(leadingSurrogate, nextCodeUnit); + else { + this._writeReplacementCharacter$0(); + return false; + } + }, + _fillBuffer$3(str, start, end) { + var t1, t2, stringIndex, codeUnit, t3, stringIndex0, t4, _this = this; + if (start !== end && P._isLeadSurrogate(str.codeUnitAt$1(0, end - 1))) + --end; + for (t1 = _this._buffer, t2 = t1.length, stringIndex = start; stringIndex < end; ++stringIndex) { + codeUnit = str.codeUnitAt$1(0, stringIndex); + if (codeUnit.$le(0, 127)) { + t3 = _this._bufferIndex; + if (t3 >= t2) + break; + _this._bufferIndex = t3 + 1; + C.NativeUint8List_methods.$indexSet(t1, t3, codeUnit); + } else if (P._isLeadSurrogate(codeUnit)) { + if (_this._bufferIndex + 4 > t2) + break; + stringIndex0 = stringIndex + 1; + if (_this._writeSurrogate$2(codeUnit, str.codeUnitAt$1(0, stringIndex0))) + stringIndex = stringIndex0; + } else if (P._isTailSurrogate(codeUnit)) { + if (_this._bufferIndex + 3 > t2) + break; + _this._writeReplacementCharacter$0(); + } else if (codeUnit.$le(0, 2047)) { + t3 = _this._bufferIndex; + t4 = t3 + 1; + if (t4 >= t2) + break; + _this._bufferIndex = t4; + t4 = C.JSInt_methods.$or(192, codeUnit.$shr(0, 6)); + if (t3 >= t2) + return H.ioore(t1, t3); + t1[t3] = t4; + t4 = _this._bufferIndex++; + t3 = C.JSInt_methods.$or(128, codeUnit.$and(0, 63)); + if (t4 >= t2) + return H.ioore(t1, t4); + t1[t4] = t3; + } else { + t3 = _this._bufferIndex; + if (t3 + 2 >= t2) + break; + _this._bufferIndex = t3 + 1; + t4 = C.JSInt_methods.$or(224, codeUnit.$shr(0, 12)); + if (t3 >= t2) + return H.ioore(t1, t3); + t1[t3] = t4; + t4 = _this._bufferIndex++; + t3 = C.JSInt_methods.$or(128, codeUnit.$shr(0, 6).$and(0, 63)); + if (t4 >= t2) + return H.ioore(t1, t4); + t1[t4] = t3; + t3 = _this._bufferIndex++; + t4 = C.JSInt_methods.$or(128, codeUnit.$and(0, 63)); + if (t3 >= t2) + return H.ioore(t1, t3); + t1[t3] = t4; + } + } + return stringIndex; + } + }; + P.Error.prototype = {}; + P.AssertionError.prototype = { + toString$0(_) { + var t1 = this.message; + if (t1 != null) + return "Assertion failed: " + P.Error_safeToString(t1); + return "Assertion failed"; + } + }; + P.NullThrownError.prototype = { + toString$0(_) { + return "Throw of null."; + } + }; + P.ArgumentError.prototype = { + get$_errorName() { + return "Invalid argument" + (!this._hasValue ? "(s)" : ""); + }, + get$_errorExplanation() { + return ""; + }, + toString$0(_) { + var explanation, errorValue, _this = this, + $name = _this.name, + nameString = $name == null ? "" : " (" + $name + ")", + message = _this.message, + messageString = message == null ? "" : ": " + message, + prefix = _this.get$_errorName() + nameString + messageString; + if (!_this._hasValue) + return prefix; + explanation = _this.get$_errorExplanation(); + errorValue = P.Error_safeToString(_this.invalidValue); + return prefix + explanation + ": " + errorValue; + } + }; + P.RangeError.prototype = { + get$_errorName() { + return "RangeError"; + }, + get$_errorExplanation() { + var explanation, + start = this.start, + end = this.end; + if (start == null) + explanation = end != null ? ": Not less than or equal to " + H.S(end) : ""; + else if (end == null) + explanation = ": Not greater than or equal to " + H.S(start); + else if (end > start) + explanation = ": Not in inclusive range " + H.S(start) + ".." + H.S(end); + else + explanation = end < start ? ": Valid value range is empty" : ": Only valid value is " + H.S(start); + return explanation; + } + }; + P.IndexError.prototype = { + get$_errorName() { + return "RangeError"; + }, + get$_errorExplanation() { + if (H._asInt(this.invalidValue) < 0) + return ": index must not be negative"; + var t1 = this.length; + if (t1 === 0) + return ": no indices are valid"; + return ": index should be less than " + t1; + }, + get$length(receiver) { + return this.length; + } + }; + P.UnsupportedError.prototype = { + toString$0(_) { + return "Unsupported operation: " + this.message; + } + }; + P.UnimplementedError.prototype = { + toString$0(_) { + var t1 = "UnimplementedError: " + this.message; + return t1; + } + }; + P.ConcurrentModificationError.prototype = { + toString$0(_) { + var t1 = this.modifiedObject; + if (t1 == null) + return "Concurrent modification during iteration."; + return "Concurrent modification during iteration: " + P.Error_safeToString(t1) + "."; + } + }; + P.CyclicInitializationError.prototype = { + toString$0(_) { + var t1 = "Reading static variable '" + this.variableName + "' during its initialization"; + return t1; + } + }; + P.Iterable.prototype = { + get$length(_) { + var count, + it = this.get$iterator(this); + for (count = 0; it.moveNext$0();) + ++count; + return count; + }, + elementAt$1(_, index) { + var t1, elementIndex, element; + P.RangeError_checkNotNegative(index, "index"); + for (t1 = this.get$iterator(this), elementIndex = 0; t1.moveNext$0();) { + element = t1.get$current(); + if (index === elementIndex) + return element; + ++elementIndex; + } + throw H.wrapException(P.IndexError$(index, this, "index", null, elementIndex)); + }, + toString$0(_) { + return P.IterableBase_iterableToShortString(this, "(", ")"); + } + }; + P.Null.prototype = { + toString$0(_) { + return "null"; + } + }; + P.Object.prototype = {$isObject: 1, + toString$0(_) { + return "Instance of '" + H.Primitives_objectTypeName(this) + "'"; + }, + toString() { + return this.toString$0(this); + } + }; + P.StringBuffer.prototype = { + get$length(_) { + return this._contents.length; + }, + toString$0(_) { + var t1 = this._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + W.DomException.prototype = { + toString$0(receiver) { + return String(receiver); + } + }; + O.Bech32Codec.prototype = {}; + O.Bech32Encoder.prototype = { + convert$2(input, maxLength) { + var checksummed, + hrp = input.hrp, + data = input.data, + t1 = hrp.length, + t2 = t1 + data.length + 1 + 6; + if (t2 > maxLength) + throw H.wrapException(new T.TooLong(t2)); + if (t1 === 0) + throw H.wrapException(new T.TooShortHrp()); + if (this.hasOutOfRangeHrpCharacters$1(hrp)) + throw H.wrapException(new T.OutOfRangeHrpCharacters(hrp)); + if (hrp.toLowerCase() !== hrp && hrp.toUpperCase() !== hrp) + throw H.wrapException(new T.MixedCase(hrp)); + hrp = hrp.toLowerCase(); + checksummed = C.JSArray_methods.$add(data, O._createChecksum(hrp, data)); + if (this.hasOutOfBoundsChars$1(checksummed)) + throw H.wrapException(new T.OutOfBoundChars("")); + t1 = H._arrayInstanceType(checksummed); + return hrp + "1" + new H.MappedListIterable(checksummed, t1._eval$1("String(1)")._as(new O.Bech32Encoder_convert_closure()), t1._eval$1("MappedListIterable<1,String>")).join$0(0); + } + }; + O.Bech32Encoder_convert_closure.prototype = { + call$1(i) { + H._asInt(i); + if (i < 0 || i >= 32) + return H.ioore(C.List_46c, i); + return C.List_46c[i]; + }, + $signature: 6 + }; + O.Bech32Validations.prototype = { + hasOutOfBoundsChars$1(data) { + return C.JSArray_methods.any$1(type$.List_int._as(data), new O.Bech32Validations_hasOutOfBoundsChars_closure()); + }, + hasOutOfRangeHrpCharacters$1(hrp) { + var t1 = new H.CodeUnits(hrp); + return t1.any$1(t1, new O.Bech32Validations_hasOutOfRangeHrpCharacters_closure()); + } + }; + O.Bech32Validations_hasOutOfBoundsChars_closure.prototype = { + call$1(c) { + return H._asInt(c) === -1; + }, + $signature: 0 + }; + O.Bech32Validations_hasOutOfRangeHrpCharacters_closure.prototype = { + call$1(c) { + return c < 33 || c > 126; + }, + $signature: 0 + }; + O.Bech32.prototype = {}; + O._polymod_closure.prototype = { + call$1(v) { + var t1, t2, $top, i; + H._asInt(v); + t1 = this._box_0; + t2 = t1.chk; + $top = t2 >>> 25; + t1.chk = ((t2 & 33554431) << 5 ^ v) >>> 0; + for (i = 0; i < 5; ++i) + if ((C.JSInt_methods._shrBothPositive$1($top, i) & 1) === 1) + t1.chk = (t1.chk ^ C.List_n7k[i]) >>> 0; + }, + $signature: 7 + }; + O._hrpExpand_closure.prototype = { + call$1(c) { + return C.JSInt_methods._shrOtherPositive$1(H._asInt(c), 5); + }, + $signature: 1 + }; + O._hrpExpand_closure0.prototype = { + call$1(c) { + return H._asInt(c) & 31; + }, + $signature: 1 + }; + O._Bech32Encoder_Converter_Bech32Validations.prototype = {}; + T.TooShortHrp.prototype = { + toString$0(_) { + return "The human readable part should have non zero length."; + } + }; + T.TooLong.prototype = { + toString$0(_) { + return "The bech32 string is too long: " + this.length + " (>90)"; + }, + get$length(receiver) { + return this.length; + } + }; + T.OutOfRangeHrpCharacters.prototype = { + toString$0(_) { + return "The human readable part contains invalid characters: " + this.hpr; + } + }; + T.MixedCase.prototype = { + toString$0(_) { + return "The human readable part is mixed case, should either be all lower or all upper case: " + this.hpr; + } + }; + T.OutOfBoundChars.prototype = { + toString$0(_) { + return "A character is undefined in bech32: " + this.char; + } + }; + N.Bolt12.prototype = {}; + K.Bolt12Decoder.prototype = { + get$_methods() { + var t1 = H.throwExpression(H.LateError$fieldNI("_methods")); + return t1; + }, + Bolt12Decoder$0() { + this.get$_methods().$indexSet(0, "lno", new K.Bolt12Decoder_closure()); + } + }; + K.Bolt12Decoder_closure.prototype = { + call$0() { + P.print("lno"); + }, + $signature: 8 + }; + M.Bolt12Encoder.prototype = {}; + Z.HashFunction.prototype = { + get$_hasher() { + var t1 = H.throwExpression(H.LateError$fieldNI("_hasher")); + return t1; + }, + sha256$2(privateKey, message) { + var tagBytes; + type$.Utf8Codec._eval$1("Codec.S")._as(privateKey); + tagBytes = C.C_Utf8Codec.get$encoder().convert$1(privateKey); + this.get$_hasher().convert$1(tagBytes).get$bytes(); + } + }; + (function aliases() { + var _ = J.JavaScriptObject.prototype; + _.super$JavaScriptObject$toString = _.toString$0; + })(); + (function installTearOffs() { + var _instance_2_u = hunkHelpers._instance_2u; + _instance_2_u(Z.HashFunction.prototype, "get$sha256", "sha256$2", 9); + })(); + (function inheritance() { + var _mixin = hunkHelpers.mixin, + _inherit = hunkHelpers.inherit, + _inheritMany = hunkHelpers.inheritMany; + _inherit(P.Object, null); + _inheritMany(P.Object, [H.JS_CONST, J.Interceptor, J.ArrayIterator, P.Error, P._ListBase_Object_ListMixin, P.Iterable, H.ListIterator, H.FixedLengthListMixin, H.UnmodifiableListMixin, H.Closure, P.MapMixin, H.Rti, H._FunctionParameters, P.StreamTransformerBase, P.ListMixin, P.Codec, P._Utf8Encoder, P.Null, P.StringBuffer, O.Bech32Validations, O.Bech32, T.TooShortHrp, T.TooLong, T.OutOfRangeHrpCharacters, T.MixedCase, T.OutOfBoundChars, N.Bolt12, K.Bolt12Decoder, M.Bolt12Encoder, Z.HashFunction]); + _inheritMany(J.Interceptor, [J.JSBool, J.JSNull, J.JavaScriptObject, J.JSArray, J.JSNumber, J.JSString, H.NativeTypedData, W.DomException]); + _inheritMany(J.JavaScriptObject, [J.PlainJavaScriptObject, J.UnknownJavaScriptObject, J.JavaScriptFunction]); + _inherit(J.JSUnmodifiableArray, J.JSArray); + _inheritMany(J.JSNumber, [J.JSInt, J.JSNumNotInt]); + _inheritMany(P.Error, [H.LateError, H.RuntimeError, P.AssertionError, H._Error, P.NullThrownError, P.ArgumentError, P.UnsupportedError, P.UnimplementedError, P.ConcurrentModificationError, P.CyclicInitializationError]); + _inherit(P.ListBase, P._ListBase_Object_ListMixin); + _inherit(H.UnmodifiableListBase, P.ListBase); + _inherit(H.CodeUnits, H.UnmodifiableListBase); + _inherit(H.EfficientLengthIterable, P.Iterable); + _inherit(H.ListIterable, H.EfficientLengthIterable); + _inherit(H.MappedListIterable, H.ListIterable); + _inheritMany(H.Closure, [H.Closure0Args, H.Closure2Args, H.TearOffClosure, H.initHooks_closure, H.initHooks_closure1, O.Bech32Encoder_convert_closure, O.Bech32Validations_hasOutOfBoundsChars_closure, O.Bech32Validations_hasOutOfRangeHrpCharacters_closure, O._polymod_closure, O._hrpExpand_closure, O._hrpExpand_closure0]); + _inheritMany(H.TearOffClosure, [H.StaticClosure, H.BoundClosure]); + _inherit(H._AssertionError, P.AssertionError); + _inherit(P.MapBase, P.MapMixin); + _inherit(H.JsLinkedHashMap, P.MapBase); + _inheritMany(H.Closure2Args, [H.initHooks_closure0, P.MapBase_mapToString_closure]); + _inherit(H.NativeTypedArray, H.NativeTypedData); + _inherit(H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin, H.NativeTypedArray); + _inherit(H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin, H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin); + _inherit(H.NativeTypedArrayOfInt, H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin); + _inherit(H.NativeUint8List, H.NativeTypedArrayOfInt); + _inherit(H._TypeError, H._Error); + _inherit(P.Converter, P.StreamTransformerBase); + _inheritMany(P.Codec, [P.Encoding, O.Bech32Codec]); + _inherit(P.Utf8Codec, P.Encoding); + _inheritMany(P.Converter, [P.Utf8Encoder, O._Bech32Encoder_Converter_Bech32Validations]); + _inheritMany(P.ArgumentError, [P.RangeError, P.IndexError]); + _inherit(O.Bech32Encoder, O._Bech32Encoder_Converter_Bech32Validations); + _inherit(K.Bolt12Decoder_closure, H.Closure0Args); + _mixin(H.UnmodifiableListBase, H.UnmodifiableListMixin); + _mixin(H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin, P.ListMixin); + _mixin(H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin, H.FixedLengthListMixin); + _mixin(P._ListBase_Object_ListMixin, P.ListMixin); + _mixin(O._Bech32Encoder_Converter_Bech32Validations, O.Bech32Validations); + })(); + var init = { + typeUniverse: {eC: new Map(), tR: {}, eT: {}, tPV: {}, sEA: []}, + mangledGlobalNames: {int: "int", double: "double", num: "num", String: "String", bool: "bool", Null: "Null", List: "List"}, + mangledNames: {}, + types: ["bool(int)", "int(int)", "@(@)", "@(@,String)", "@(String)", "~(Object?,Object?)", "String(int)", "~(int)", "Null()", "Digest(String,String)"], + interceptorsByTag: null, + leafTags: null, + arrayRti: Symbol("$ti") + }; + H._Universe_addRules(init.typeUniverse, JSON.parse('{"PlainJavaScriptObject":"JavaScriptObject","UnknownJavaScriptObject":"JavaScriptObject","JavaScriptFunction":"JavaScriptObject","JSBool":{"bool":[]},"JSArray":{"List":["1"],"Iterable":["1"]},"JSUnmodifiableArray":{"JSArray":["1"],"List":["1"],"Iterable":["1"]},"JSNumber":{"num":[]},"JSInt":{"int":[],"num":[]},"JSNumNotInt":{"num":[]},"JSString":{"String":[]},"CodeUnits":{"ListMixin":["int"],"UnmodifiableListMixin":["int"],"List":["int"],"Iterable":["int"],"ListMixin.E":"int"},"EfficientLengthIterable":{"Iterable":["1"]},"ListIterable":{"Iterable":["1"]},"MappedListIterable":{"ListIterable":["2"],"Iterable":["2"],"ListIterable.E":"2"},"UnmodifiableListBase":{"ListMixin":["1"],"UnmodifiableListMixin":["1"],"List":["1"],"Iterable":["1"]},"JsLinkedHashMap":{"MapMixin":["1","2"],"Map":["1","2"]},"NativeTypedArray":{"JavaScriptIndexingBehavior":["1"]},"NativeTypedArrayOfInt":{"ListMixin":["int"],"JavaScriptIndexingBehavior":["int"],"List":["int"],"Iterable":["int"],"FixedLengthListMixin":["int"]},"NativeUint8List":{"ListMixin":["int"],"Uint8List":[],"JavaScriptIndexingBehavior":["int"],"List":["int"],"Iterable":["int"],"FixedLengthListMixin":["int"],"ListMixin.E":"int"},"ListBase":{"ListMixin":["1"],"List":["1"],"Iterable":["1"]},"MapBase":{"MapMixin":["1","2"],"Map":["1","2"]},"MapMixin":{"Map":["1","2"]},"Encoding":{"Codec":["String","List"]},"Utf8Codec":{"Codec":["String","List"],"Codec.S":"String"},"Utf8Encoder":{"Converter":["String","List"]},"int":{"num":[]},"List":{"Iterable":["1"]},"Bech32Codec":{"Codec":["Bech32","String"],"Codec.S":"Bech32"},"Bech32Encoder":{"Converter":["Bech32","String"]}}')); + H._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"EfficientLengthIterable":1,"UnmodifiableListBase":1,"NativeTypedArray":1,"StreamTransformerBase":2,"ListBase":1,"MapBase":2,"_ListBase_Object_ListMixin":1}')); + var type$ = (function rtii() { + var findType = H.findType; + return { + CodeUnits: findType("CodeUnits"), + Function: findType("Function"), + Hash: findType("Hash"), + Iterable_dynamic: findType("Iterable<@>"), + JSArray_String: findType("JSArray"), + JSArray_dynamic: findType("JSArray<@>"), + JSArray_int: findType("JSArray"), + JSNull: findType("JSNull"), + JavaScriptFunction: findType("JavaScriptFunction"), + JavaScriptIndexingBehavior_dynamic: findType("JavaScriptIndexingBehavior<@>"), + List_dynamic: findType("List<@>"), + List_int: findType("List"), + Map_int_dynamic: findType("Map"), + Map_of_int_and_List_dynamic: findType("Map>"), + Map_of_int_and_List_int: findType("Map>"), + Null: findType("Null"), + Object: findType("Object"), + String: findType("String"), + UnknownJavaScriptObject: findType("UnknownJavaScriptObject"), + Utf8Codec: findType("Utf8Codec"), + bool: findType("bool"), + double: findType("double"), + dynamic: findType("@"), + int: findType("int"), + legacy_Never: findType("0&*"), + legacy_Object: findType("Object*"), + nullable_Future_Null: findType("Future?"), + nullable_Object: findType("Object?"), + num: findType("num") + }; + })(); + (function constants() { + var makeConstList = hunkHelpers.makeConstList; + C.Interceptor_methods = J.Interceptor.prototype; + C.JSArray_methods = J.JSArray.prototype; + C.JSInt_methods = J.JSInt.prototype; + C.JSNumber_methods = J.JSNumber.prototype; + C.JSString_methods = J.JSString.prototype; + C.JavaScriptFunction_methods = J.JavaScriptFunction.prototype; + C.NativeUint8List_methods = H.NativeUint8List.prototype; + C.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.prototype; + C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; + C.C_JS_CONST = function getTagFallback(o) { + var s = Object.prototype.toString.call(o); + return s.substring(8, s.length - 1); +}; + C.C_JS_CONST0 = function() { + var toStringFunction = Object.prototype.toString; + function getTag(o) { + var s = toStringFunction.call(o); + return s.substring(8, s.length - 1); + } + function getUnknownTag(object, tag) { + if (/^HTML[A-Z].*Element$/.test(tag)) { + var name = toStringFunction.call(object); + if (name == "[object Object]") return null; + return "HTMLElement"; + } + } + function getUnknownTagGenericBrowser(object, tag) { + if (self.HTMLElement && object instanceof HTMLElement) return "HTMLElement"; + return getUnknownTag(object, tag); + } + function prototypeForTag(tag) { + if (typeof window == "undefined") return null; + if (typeof window[tag] == "undefined") return null; + var constructor = window[tag]; + if (typeof constructor != "function") return null; + return constructor.prototype; + } + function discriminator(tag) { return null; } + var isBrowser = typeof navigator == "object"; + return { + getTag: getTag, + getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, + prototypeForTag: prototypeForTag, + discriminator: discriminator }; +}; + C.C_JS_CONST6 = function(getTagFallback) { + return function(hooks) { + if (typeof navigator != "object") return hooks; + var ua = navigator.userAgent; + if (ua.indexOf("DumpRenderTree") >= 0) return hooks; + if (ua.indexOf("Chrome") >= 0) { + function confirm(p) { + return typeof window == "object" && window[p] && window[p].name == p; + } + if (confirm("Window") && confirm("HTMLElement")) return hooks; + } + hooks.getTag = getTagFallback; + }; +}; + C.C_JS_CONST1 = function(hooks) { + if (typeof dartExperimentalFixupGetTag != "function") return hooks; + hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag); +}; + C.C_JS_CONST2 = function(hooks) { + var getTag = hooks.getTag; + var prototypeForTag = hooks.prototypeForTag; + function getTagFixed(o) { + var tag = getTag(o); + if (tag == "Document") { + if (!!o.xmlVersion) return "!Document"; + return "!HTMLDocument"; + } + return tag; + } + function prototypeForTagFixed(tag) { + if (tag == "Document") return null; + return prototypeForTag(tag); + } + hooks.getTag = getTagFixed; + hooks.prototypeForTag = prototypeForTagFixed; +}; + C.C_JS_CONST5 = function(hooks) { + var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; + if (userAgent.indexOf("Firefox") == -1) return hooks; + var getTag = hooks.getTag; + var quickMap = { + "BeforeUnloadEvent": "Event", + "DataTransfer": "Clipboard", + "GeoGeolocation": "Geolocation", + "Location": "!Location", + "WorkerMessageEvent": "MessageEvent", + "XMLDocument": "!Document"}; + function getTagFirefox(o) { + var tag = getTag(o); + return quickMap[tag] || tag; + } + hooks.getTag = getTagFirefox; +}; + C.C_JS_CONST4 = function(hooks) { + var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; + if (userAgent.indexOf("Trident/") == -1) return hooks; + var getTag = hooks.getTag; + var quickMap = { + "BeforeUnloadEvent": "Event", + "DataTransfer": "Clipboard", + "HTMLDDElement": "HTMLElement", + "HTMLDTElement": "HTMLElement", + "HTMLPhraseElement": "HTMLElement", + "Position": "Geoposition" + }; + function getTagIE(o) { + var tag = getTag(o); + var newTag = quickMap[tag]; + if (newTag) return newTag; + if (tag == "Object") { + if (window.DataView && (o instanceof window.DataView)) return "DataView"; + } + return tag; + } + function prototypeForTagIE(tag) { + var constructor = window[tag]; + if (constructor == null) return null; + return constructor.prototype; + } + hooks.getTag = getTagIE; + hooks.prototypeForTag = prototypeForTagIE; +}; + C.C_JS_CONST3 = function(hooks) { return hooks; } +; + C.C_Utf8Codec = new P.Utf8Codec(); + C.C_Utf8Encoder = new P.Utf8Encoder(); + C.List_46c = H._setArrayType(makeConstList(["q", "p", "z", "r", "y", "9", "x", "8", "g", "f", "2", "t", "v", "d", "w", "0", "s", "3", "j", "n", "5", "4", "k", "h", "c", "e", "6", "m", "u", "a", "7", "l"]), type$.JSArray_String); + C.List_n7k = H._setArrayType(makeConstList([996825010, 642813549, 513874426, 1027748829, 705979059]), type$.JSArray_int); + })(); + (function staticFields() { + $._JS_INTEROP_INTERCEPTOR_TAG = null; + $.Closure_functionCounter = 0; + $.BoundClosure__receiverFieldNameCache = null; + $.BoundClosure__interceptorFieldNameCache = null; + $.getTagFunction = null; + $.alternateTagFunction = null; + $.prototypeForTagFunction = null; + $.dispatchRecordsForInstanceTags = null; + $.interceptorsForUncacheableTags = null; + $.initNativeDispatchFlag = null; + $._toStringVisiting = H._setArrayType([], H.findType("JSArray")); + })(); + (function lazyInitializers() { + var _lazyFinal = hunkHelpers.lazyFinal; + _lazyFinal($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", function() { + return H.getIsolateAffinityTag("_$dart_dartClosure"); + }); + })(); + (function nativeSupport() { + !function() { + var intern = function(s) { + var o = {}; + o[s] = 1; + return Object.keys(hunkHelpers.convertToFastObject(o))[0]; + }; + init.getIsolateTag = function(name) { + return intern("___dart_" + name + init.isolateTag); + }; + var tableProperty = "___dart_isolate_tags_"; + var usedProperties = Object[tableProperty] || (Object[tableProperty] = Object.create(null)); + var rootProperty = "_ZxYxX"; + for (var i = 0;; i++) { + var property = intern(rootProperty + "_" + i + "_"); + if (!(property in usedProperties)) { + usedProperties[property] = 1; + init.isolateTag = property; + break; + } + } + init.dispatchPropertyName = init.getIsolateTag("dispatch_record"); + }(); + hunkHelpers.setOrUpdateInterceptorsByTag({ApplicationCacheErrorEvent: J.Interceptor, DOMError: J.Interceptor, ErrorEvent: J.Interceptor, Event: J.Interceptor, InputEvent: J.Interceptor, SubmitEvent: J.Interceptor, MediaError: J.Interceptor, NavigatorUserMediaError: J.Interceptor, OverconstrainedError: J.Interceptor, PositionError: J.Interceptor, GeolocationPositionError: J.Interceptor, SensorErrorEvent: J.Interceptor, SpeechRecognitionError: J.Interceptor, SQLError: J.Interceptor, ArrayBufferView: H.NativeTypedData, Uint8Array: H.NativeUint8List, DOMException: W.DomException}); + hunkHelpers.setOrUpdateLeafTags({ApplicationCacheErrorEvent: true, DOMError: true, ErrorEvent: true, Event: true, InputEvent: true, SubmitEvent: true, MediaError: true, NavigatorUserMediaError: true, OverconstrainedError: true, PositionError: true, GeolocationPositionError: true, SensorErrorEvent: true, SpeechRecognitionError: true, SQLError: true, ArrayBufferView: false, Uint8Array: false, DOMException: true}); + H.NativeTypedArray.$nativeSuperclassTag = "ArrayBufferView"; + H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin.$nativeSuperclassTag = "ArrayBufferView"; + H._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin.$nativeSuperclassTag = "ArrayBufferView"; + H.NativeTypedArrayOfInt.$nativeSuperclassTag = "ArrayBufferView"; + })(); + Function.prototype.call$0 = function() { + return this(); + }; + Function.prototype.call$1 = function(a) { + return this(a); + }; + Function.prototype.call$2 = function(a, b) { + return this(a, b); + }; + convertAllToFastObject(holders); + convertToFastObject($); + (function(callback) { + if (typeof document === "undefined") { + callback(null); + return; + } + if (typeof document.currentScript != "undefined") { + callback(document.currentScript); + return; + } + var scripts = document.scripts; + function onLoad(event) { + for (var i = 0; i < scripts.length; ++i) + scripts[i].removeEventListener("load", onLoad, false); + callback(event.target); + } + for (var i = 0; i < scripts.length; ++i) + scripts[i].addEventListener("load", onLoad, false); + })(function(currentScript) { + init.currentScript = currentScript; + var callMain = F.main; + if (typeof dartMainRunner === "function") + dartMainRunner(callMain, []); + else + callMain([]); + }); +})(); + +//# sourceMappingURL=example.js.map diff --git a/example/example.js.deps b/example/example.js.deps new file mode 100644 index 0000000..f02e9a1 --- /dev/null +++ b/example/example.js.deps @@ -0,0 +1,241 @@ +file:///home/vincent/.pub-cache/git/dart-bip340-37f5f5c47004070afcd418915a34fc01d7fddd80/lib/bip340.dart +file:///home/vincent/.pub-cache/git/dart-bip340-37f5f5c47004070afcd418915a34fc01d7fddd80/lib/src/bip340.dart +file:///home/vincent/.pub-cache/git/dart-bip340-37f5f5c47004070afcd418915a34fc01d7fddd80/lib/src/helpers.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/bech32-0.2.1/lib/bech32.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/bech32-0.2.1/lib/src/bech32.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/bech32-0.2.1/lib/src/exceptions.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/bech32-0.2.1/lib/src/segwit.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/collection.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/algorithms.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/canonicalized_map.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/combined_wrappers/combined_iterable.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/combined_wrappers/combined_iterator.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/combined_wrappers/combined_list.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/combined_wrappers/combined_map.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/comparators.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/empty_unmodifiable_set.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/equality.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/equality_map.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/equality_set.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/functions.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/iterable_extensions.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/iterable_zip.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/list_extensions.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/priority_queue.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/queue_list.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/union_set.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/union_set_controller.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/unmodifiable_wrappers.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/utils.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/collection-1.15.0/lib/src/wrappers.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/convert.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/accumulator_sink.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/byte_accumulator_sink.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/charcodes.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/codepage.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/hex.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/hex/decoder.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/hex/encoder.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/identity_codec.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/percent.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/percent/decoder.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/percent/encoder.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/string_accumulator_sink.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/convert-3.0.1/lib/src/utils.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/crypto.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/digest.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/digest_sink.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/hash.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/hash_sink.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/hmac.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/md5.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/sha1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/sha256.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/sha512.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/sha512_slowsinks.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/crypto-3.0.1/lib/src/utils.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/js-0.6.3/lib/js.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/adapters/stream_cipher_as_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/api.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/asymmetric/api.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/asymmetric/oaep.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/asymmetric/pkcs1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/asymmetric/rsa.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/aes_fast.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/cbc.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/ccm.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/cfb.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/ctr.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/ecb.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/gcm.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/gctr.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/ige.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/ofb.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/block/modes/sic.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/blake2b.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/cshake.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/keccak.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/md2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/md4.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/md5.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/ripemd128.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/ripemd160.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/ripemd256.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/ripemd320.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha224.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha256.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha3.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha384.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha512.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sha512t.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/shake.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/sm3.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/tiger.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/whirlpool.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/digests/xof_utils.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/api.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp160r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp160t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp192r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp192t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp224r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp224t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp256r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp256t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp320r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp320t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp384r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp384t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp512r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/brainpoolp512t1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/gostr3410_2001_cryptopro_a.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/gostr3410_2001_cryptopro_b.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/gostr3410_2001_cryptopro_c.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/gostr3410_2001_cryptopro_xcha.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/gostr3410_2001_cryptopro_xchb.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime192v1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime192v2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime192v3.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime239v1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime239v2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime239v3.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/prime256v1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp112r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp112r2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp128r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp128r2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp160k1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp160r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp160r2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp192k1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp192r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp224k1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp224r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp256k1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp256r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp384r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/curves/secp521r1.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/ecc_base.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/ecc/ecc_fp.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/export.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/impl.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_derivators/api.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_derivators/argon2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_derivators/argon2_register64_impl.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_derivators/hkdf.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_derivators/pbkdf2.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_derivators/scrypt.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_generators/api.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_generators/ec_key_generator.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/key_generators/rsa_key_generator.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/macs/cbc_block_cipher_mac.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/macs/cmac.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/macs/hmac.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/macs/poly1305.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/padded_block_cipher/padded_block_cipher_impl.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/paddings/iso7816d4.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/paddings/pkcs7.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/random/auto_seed_block_ctr_random.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/random/block_ctr_random.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/random/fortuna_random.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/signers/ecdsa_signer.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/signers/pss_signer.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/signers/rsa_signer.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/aead_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/aead_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/aead_parameters.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/algorithm.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/asymmetric_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/asymmetric_key.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/asymmetric_key_pair.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/asymmetric_key_parameter.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/cipher_parameters.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/digest.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/key_derivator.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/key_generator.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/key_generator_parameters.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/key_parameter.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/mac.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/padded_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/padded_block_cipher_parameters.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/padding.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/parameters_with_iv.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/parameters_with_random.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/parameters_with_salt.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/parameters_with_salt_configuration.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/private_key.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/private_key_parameter.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/public_key.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/public_key_parameter.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/registry_factory_exception.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/secure_random.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/signature.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/signer.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/srp_client.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/srp_server.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/stream_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/api/xof.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/ec_standard_curve_constructor.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_aead_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_aead_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_asymmetric_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_block_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_digest.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_key_derivator.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_mac.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_padding.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/base_stream_cipher.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/entropy.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/keccak_engine.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/long_sha2_family_digest.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/md4_family_digest.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/impl/secure_random_base.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/platform_check/node_crypto.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/platform_check/platform_check.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/platform_check/web.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/registry/registration.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/registry/registry.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/ufixnum.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/src/utils.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/stream/chacha20.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/stream/chacha20poly1305.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/stream/chacha7539.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/stream/ctr.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/stream/salsa20.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/pointycastle-3.3.4/lib/stream/sic.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/typed_data-1.3.0/lib/src/typed_buffer.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/typed_data-1.3.0/lib/src/typed_queue.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/typed_data-1.3.0/lib/typed_buffers.dart +file:///home/vincent/.pub-cache/hosted/pub.dartlang.org/typed_data-1.3.0/lib/typed_data.dart +file:///home/vincent/Github/bolt12/dart/.dart_tool/package_config.json +file:///home/vincent/Github/bolt12/dart/example/main.dart +file:///home/vincent/Github/bolt12/dart/lib/bolt12.dart +file:///home/vincent/Github/bolt12/dart/lib/src/bolt12.dart +file:///home/vincent/Github/bolt12/dart/lib/src/core/bolt12_content.dart +file:///home/vincent/Github/bolt12/dart/lib/src/core/bolt12_decoder.dart +file:///home/vincent/Github/bolt12/dart/lib/src/core/bolt12_encoder.dart +file:///home/vincent/Github/bolt12/dart/lib/src/utils/hash_function.dart +file:///usr/lib/dart/lib/_internal/dart2js_nnbd_strong_platform.dill +file:///usr/lib/dart/lib/libraries.json \ No newline at end of file diff --git a/example/example.js.map b/example/example.js.map new file mode 100644 index 0000000..60b03af --- /dev/null +++ b/example/example.js.map @@ -0,0 +1,16 @@ +{ + "version": 3, + "engine": "v2", + "file": "example.js", + "sourceRoot": "", + "sources": ["main.dart","../lib/src/core/bolt12_encoder.dart","../../../../.pub-cache/hosted/pub.dartlang.org/bech32-0.2.1/lib/src/bech32.dart","../lib/src/bolt12.dart","../lib/src/utils/hash_function.dart","org-dartlang-sdk:///lib/internal/errors.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/js_helper.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/rti.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/native_helper.dart","org-dartlang-sdk:///lib/core/errors.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/interceptors.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/native_typed_data.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/js_names.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/shared/recipe_syntax.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/js_primitives.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/late_helper.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/js_array.dart","../lib/src/core/bolt12_decoder.dart","org-dartlang-sdk:///lib/internal/iterable.dart","org-dartlang-sdk:///lib/internal/internal.dart","org-dartlang-sdk:///lib/collection/list.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/linked_hash_map.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/collection_patch.dart","org-dartlang-sdk:///lib/collection/iterable.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/core_patch.dart","org-dartlang-sdk:///lib/collection/maps.dart","org-dartlang-sdk:///lib/convert/utf.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/js_string.dart","org-dartlang-sdk:///lib/core/print.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/internal_patch.dart","org-dartlang-sdk:///lib/_internal/js_runtime/lib/js_number.dart","org-dartlang-sdk:///lib/core/iterable.dart","org-dartlang-sdk:///lib/core/null.dart","org-dartlang-sdk:///lib/html/dart2js/html_dart2js.dart","../../../../.pub-cache/hosted/pub.dartlang.org/bech32-0.2.1/lib/src/exceptions.dart","org-dartlang-sdk:///lib/convert/codec.dart"], + "names": ["main","Bolt12","Bolt12Encoder","HashFunction","Bolt12Encoder.encode","Bolt12.encode","Bolt12Encoder.toBech32","Bech32Codec.encode","LateError.fieldNI","unminifyOrTag","isJsIndexable","S","Primitives.objectTypeName","Primitives._objectTypeNameNewRti","ioore","diagnoseIndexError","diagnoseRangeError","argumentErrorValue","wrapException","toStringWrapper","throwExpression","throwConcurrentModificationError","Closure.fromTearOff","Closure._computeSignatureFunctionNewRti","Closure.cspForwardCall","Closure.forwardCallTo","Closure.cspForwardInterceptedCall","Closure.forwardInterceptedCallTo","closureFromTearOff","BoundClosure.evalRecipe","evalInInstance","BoundClosure.receiverOf","BoundClosure.interceptorOf","BoundClosure._computeFieldNamed","boolConversionCheck","assertThrow","throwCyclicInit","getIsolateAffinityTag","lookupAndCacheInterceptor","patchProto","patchInteriorProto","makeLeafDispatchRecord","makeDefaultDispatchRecord","initNativeDispatch","initNativeDispatchContinue","lookupInterceptor","initHooks","applyHooksTransformer","_checkValidIndex","_checkValidRange","Rti._getQuestionFromStar","Rti._getFutureFromFutureOr","Rti._isUnionOfFunctionType","Rti._getCanonicalRecipe","findType","_substitute","_substituteArray","_substituteNamed","_substituteFunctionParameters","_FunctionParameters.allocate","_setArrayType","closureFunctionType","instanceOrFunctionType","_isClosure","instanceType","_isDartObject","_arrayInstanceType","_instanceType","_instanceTypeFromConstructor","_instanceTypeFromConstructorMiss","getTypeFromTypesTable","_installSpecializedIsTest","_finishIsFn","_installSpecializedAsCheck","_nullIs","_generalIsTestImplementation","_generalNullableIsTestImplementation","_isTestViaProperty","_isListTestViaProperty","_generalAsCheckImplementation","_generalNullableAsCheckImplementation","_failedAsCheck","_Error.compose","_TypeError.fromMessage","_TypeError.forType","_isObject","_asObject","_isTop","_asTop","_isBool","_asBool","_asBoolS","_asBoolQ","_asDouble","_asDoubleS","_asDoubleQ","_isInt","_asInt","_asIntS","_asIntQ","_isNum","_asNum","_asNumS","_asNumQ","_isString","_asString","_asStringS","_asStringQ","_rtiArrayToString","_functionRtiToString","isTopType","Rti._getReturnType","_rtiToString","Rti._getGenericFunctionParameterIndex","_unminifyOrTag","_Universe.findRule","_Universe.findErasedType","_Universe.addRules","_Universe.addErasedTypes","_Universe.eval","_Universe.evalInEnvironment","_Universe.bind","_Universe._installTypeTests","_Universe._lookupTerminalRti","Rti.allocate","_Universe._createTerminalRti","_Universe._lookupStarRti","_Universe._canonicalRecipeOfStar","_Universe._createStarRti","_Universe._lookupQuestionRti","_Universe._canonicalRecipeOfQuestion","_Universe._createQuestionRti","_Universe._lookupFutureOrRti","_Universe._canonicalRecipeOfFutureOr","_Universe._createFutureOrRti","_Universe._lookupGenericFunctionParameterRti","_Universe._createGenericFunctionParameterRti","_Universe._canonicalRecipeJoin","_Universe._canonicalRecipeJoinNamed","_Universe._lookupInterfaceRti","_Universe._createInterfaceRti","_Universe._lookupBindingRti","_Universe._canonicalRecipeOfBinding","_Universe._createBindingRti","_Universe._lookupFunctionRti","_Universe._canonicalRecipeOfFunction","_Universe._createFunctionRti","_Universe._lookupGenericFunctionRti","_Universe._canonicalRecipeOfGenericFunction","_Universe._createGenericFunctionRti","_Parser.create","_Parser.parse","_Parser.pushStackFrame","_Parser.handleTypeArguments","_Parser.collectArray","_Parser.handleFunctionArguments","_Parser.handleOptionalGroup","_Parser.handleNamedGroup","_Parser.collectNamed","_Parser.handleDigit","_Parser.handleIdentifier","_Parser.handleExtendedOperations","_Parser.toType","_Parser.toTypes","_Parser.toTypesNamed","_Parser.indexToType","_isSubtype","_isFunctionSubtype","_isInterfaceSubtype","Rti._getInterfaceTypeArguments","_areArgumentsSubtypes","isNullable","isStrongTopType","_Utils.objectAssign","_Utils.newArrayOrEmpty","printString","throwLateFieldADI","makeDispatchRecord","getNativeInterceptor","lookupInterceptorByConstructor","cacheInterceptorOnConstructor","JSArray.markFixedList","Bolt12Decoder","_polymod","_hrpExpand","ListMixin.map","JSString.codeUnits","_createChecksum","JsLinkedHashMap.es6","LinkedHashMap._empty","IterableBase.iterableToShortString","IterableBase.iterableToFullString","_isToStringVisiting","_iterablePartsToStrings","MapBase.mapToString","_isLeadSurrogate","_isTailSurrogate","_combineSurrogatePair","Error._objectToString","List.of","List._of","StringBuffer._writeAll","Error.safeToString","AssertionError","ArgumentError","RangeError.range","RangeError.checkValidRange","RangeError.checkNotNegative","IndexError","UnsupportedError","UnimplementedError","ConcurrentModificationError","print","Interceptor.toString","JSBool.toString","JSNull.toString","JavaScriptObject.toString","JavaScriptFunction.toString","JSArray.add","JSArray.addAll","JSArray._addAllFromArray","JSArray.forEach","JSArray.elementAt","JSArray.any","JSArray.toString","JSArray.iterator","JSArray.length","JSArray.[]=","JSArray.+","ArrayIterator.current","ArrayIterator.moveNext","ArrayIterator._current","JSNumber.toString","JSNumber.+","JSNumber._shrOtherPositive","JSNumber._shrReceiverPositive","JSNumber._shrBothPositive","JSNumber.|","JSString.codeUnitAt","JSString.+","JSString.toString","JSString.length","LateError.toString","CodeUnits.[]","CodeUnits.length","ListIterable.iterator","ListIterable.join","ListIterator.current","ListIterator.moveNext","ListIterator._current","MappedListIterable.length","MappedListIterable.elementAt","Closure.toString","StaticClosure.toString","BoundClosure.toString","RuntimeError.toString","_AssertionError.toString","JsLinkedHashMap.length","JsLinkedHashMap.forEach","JsLinkedHashMap.toString","initHooks.","NativeTypedArray.length","NativeTypedArrayOfInt.[]=","NativeUint8List.length","NativeUint8List.[]","Rti._eval","Rti._bind","_Error.toString","ListMixin.iterator","ListMixin.elementAt","ListMixin.any","ListMixin.toString","MapBase.mapToString.","StringBuffer.write","MapMixin.toString","MapMixin.length","Utf8Codec.encoder","Utf8Encoder.convert","_Utf8Encoder._writeReplacementCharacter","_Utf8Encoder._writeSurrogate","_Utf8Encoder._fillBuffer","AssertionError.toString","NullThrownError.toString","ArgumentError._errorName","ArgumentError._errorExplanation","ArgumentError.toString","RangeError._errorName","RangeError._errorExplanation","IndexError._errorName","IndexError._errorExplanation","UnsupportedError.toString","UnimplementedError.toString","ConcurrentModificationError.toString","CyclicInitializationError.toString","Iterable.length","Iterable.elementAt","Iterable.toString","Null.toString","Object.toString","StringBuffer.length","StringBuffer.toString","DomException.toString","Bech32Encoder.convert","JSArray.map","Bech32Encoder.convert.","Bech32Validations.hasOutOfBoundsChars","Bech32Validations.hasOutOfRangeHrpCharacters","Bech32Validations.hasOutOfBoundsChars.","Bech32Validations.hasOutOfRangeHrpCharacters.","_polymod.","_hrpExpand.","TooShortHrp.toString","TooLong.toString","OutOfRangeHrpCharacters.toString","MixedCase.toString","OutOfBoundChars.toString","Bolt12Decoder._methods","Bolt12Decoder.","HashFunction._hasher","HashFunction.sha256","DART_CLOSURE_PROPERTY_NAME","patchInstance","JS_INTEROP_INTERCEPTOR_TAG","Bech32Codec","","_empty","fieldNI","Bech32Encoder","Bech32","LateError","CyclicInitializationError","NullThrownError","objectTypeName","_objectTypeNameNewRti","Object","RangeError","safeToString","_objectToString","Closure","iterableToFullString","StringBuffer","_toStringVisiting","_writeAll","ArrayIterator","JSArray","ListIterator","ListMixin","Iterable","initNativeDispatchFlag","_JS_INTEROP_INTERCEPTOR_TAG","getTagFunction","dispatchRecordsForInstanceTags","interceptorsForUncacheableTags","alternateTagFunction","JavaScriptIndexingBehavior","prototypeForTagFunction","initHooks_closure","fromTearOff","StaticClosure","BoundClosure","functionCounter","forwardCallTo","_computeSignatureFunctionNewRti","evalRecipe","evalInEnvironment","create","parse","handleDigit","handleIdentifier","toType","_lookupGenericFunctionParameterRti","_lookupTerminalRti","toTypes","_lookupInterfaceRti","_lookupGenericFunctionRti","_lookupBindingRti","handleExtendedOperations","_lookupStarRti","_lookupQuestionRti","_lookupFutureOrRti","_FunctionParameters","_lookupFunctionRti","toTypesNamed","_canonicalRecipeJoin","_canonicalRecipeJoinNamed","Rti","_installTypeTests","_createFutureOrRti","Future","_createQuestionRti","_getQuestionFromStar","_createStarRti","_createGenericFunctionRti","newArrayOrEmpty","indexToType","findRule","_getCanonicalRecipe","forwardInterceptedCallTo","cspForwardCall","_receiverFieldNameCache","_computeFieldNamed","markFixedList","receiverOf","_interceptorFieldNameCache","cspForwardInterceptedCall","interceptorOf","RuntimeError","Codec","checkValidRange","_Utf8Encoder","range","forType","_TypeError","compose","fromMessage","_isUnionOfFunctionType","eval","_getFutureFromFutureOr","List","bind","findErasedType","TooLong","TooShortHrp","OutOfRangeHrpCharacters","MixedCase","OutOfBoundChars","MappedListIterable","String","Bech32Encoder_convert_closure","iterableToShortString","ListIterable","checkNotNegative","Bech32Validations_hasOutOfBoundsChars_closure","bool","_AssertionError","of","_of","_polymod_closure","int","CodeUnits","_hrpExpand_closure","Bech32Validations_hasOutOfRangeHrpCharacters_closure","JsLinkedHashMap","mapToString","MapBase_mapToString_closure","Bolt12Decoder_closure","objectAssign","JS_CONST","Interceptor","JSBool","JSNull","JavaScriptObject","PlainJavaScriptObject","UnknownJavaScriptObject","JavaScriptFunction","JSUnmodifiableArray","num","JSNumber","JSInt","JSNumNotInt","JSString","EfficientLengthIterable","FixedLengthListMixin","UnmodifiableListMixin","UnmodifiableListBase","Closure0Args","Closure2Args","TearOffClosure","NativeTypedData","NativeTypedArray","NativeTypedArrayOfInt","Uint8List","NativeUint8List","_Error","StreamTransformerBase","ListBase","MapBase","Map","MapMixin","Converter","Encoding","Utf8Codec","Utf8Encoder","Error","Null","ApplicationCacheErrorEvent","DomError","DomException","ErrorEvent","Event","MediaError","NavigatorUserMediaError","OverconstrainedError","PositionError","SensorErrorEvent","SpeechRecognitionError","SqlError","Bech32Validations","Digest","_NativeTypedArrayOfInt&NativeTypedArray&ListMixin","_NativeTypedArrayOfInt&NativeTypedArray&ListMixin&FixedLengthListMixin","_ListBase&Object&ListMixin","_Bech32Encoder&Converter&Bech32Validations","addRules","addErasedTypes","double","Function","Hash","getInterceptor$","getInterceptor$asx","getInterceptor$ax","toString","_captured_prototypeForTag_0","_captured_getUnknownTag_0","_captured_getTag_0","dart.collection#_box_0","_captured_result_1","bolt12_encoder.dart#_#Bolt12Encoder#_bech32codec","hash_function.dart#_#HashFunction#_hasher","sha256","rti#_as","convert","data","variableName","dart._internal#_message","_js_helper#_receiver","rti#_is","rti#_kind","rti#_primary","rti#_rest","length","end","start","name","message","dart.core#_errorName","dart.core#_hasValue","dart.core#_errorExplanation","invalidValue","add","rti#_requiredPositional","rti#_optionalPositional","rti#_named","rti#_precomputed1","dart.core#_contents","iterator","moveNext","current","rti#_eval","_interceptors#_iterable","_interceptors#_length","_interceptors#_index","_interceptors#_current=","modifiedObject","dart._internal#_iterable","dart._internal#_length","dart._internal#_index","dart._internal#_current=","elementAt","hrp","rti#_evalCache","rti#_canonicalRecipe","rti#_bindCache","rti#_cachedRuntimeType","rti#_specializedTestResource","_js_helper#_interceptor","encoder","hash_function.dart#_hasher","bytes","dart.convert#_fillBuffer","codeUnitAt","dart.convert#_writeReplacementCharacter","dart.convert#_bufferIndex","dart.convert#_buffer","dart.convert#_writeSurrogate","bolt12.dart#_#Bolt12#_encoder","rti#_message","hasOutOfRangeHrpCharacters","hasOutOfBoundsChars","join","dart._internal#_f","dart._internal#_source","char","hpr","any","addAll","_interceptors#_addAllFromArray","_interceptors#_shrReceiverPositive","_interceptors#_shrBothPositive","chk","forEach","dart._internal#_string","_interceptors#_shrOtherPositive","rti#_bind","first","_js_helper#_first","_js_helper#_modifications","hashMapCellKey","hashMapCellValue","_js_helper#_next","_js_helper#_length","_js_helper#_map","_js_helper#_last","_js_helper#_rest","_js_helper#_nums","_js_helper#_strings","bolt12_decoder.dart#_methods","code","hashCode","checkMutable","checkGrowable","removeLast","map","last","toList","_interceptors#_toListGrowable","_interceptors#_toListFixed","[]=","+","_interceptors#_shlPositive","|","_interceptors#_codeUnitAt","toLowerCase","toUpperCase","codeUnits","isEmpty","[]","call","_js_helper#_name","_js_helper#_target","keys","internalGet","internalSet","_js_helper#_addHashTableEntry","_js_helper#_modified","_js_helper#_newLinkedCell","internalComputeHashCode","_js_helper#_getBucket","internalFindBucketIndex","_js_helper#_getTableCell","_js_helper#_getTableBucket","_js_helper#_setTableEntry","_js_helper#_deleteTableEntry","_js_helper#_newHashTable","_js_helper#_captured_getTag_0","_js_helper#_captured_getUnknownTag_0","_js_helper#_captured_prototypeForTag_0","sublist","rti#_precomputed2","rti#_precomputed3","rti#_precomputed4","getRange","dart.collection#_captured_result_1","encode","dart.convert#_allowMalformed","dart.convert#_carry","indexable","write","writeAll","dart.core#_writeString","isMixedCase","bech32.dart#_box_0","bolt12.dart#_encoder","bolt12.dart#_decoder=","bolt12.dart#_hashFunction=","bolt12.dart#_#Bolt12#_decoder","bolt12.dart#_#Bolt12#_hashFunction","bolt12_decoder.dart#_bech32codec=","bolt12_decoder.dart#_#Bolt12Decoder#_methods","bolt12_decoder.dart#_#Bolt12Decoder#_bech32codec","bolt12_encoder.dart#_bech32codec","toBech32","$add","$index","$le","$indexSet","$shr","$or","$and","$shl","$eq","$sub","$div","$mul","$xor","$lt","$gt","$ge","_bech32codec","_hasher","instanceTypeName","constructorNameFallback","_saneNativeClassName","value","receiverFieldName","interceptorFieldName","_rtiEval","setDispatchProperty","propertyGet","_setPrecomputed1","_lookupFutureRti","asString","asBool","allocate","_setRequiredPositional","_setOptionalPositional","_setNamed","instanceOf","_getKind","_setSpecializedTestResource","_setIsTestFunction","_setAsCheckFunction","isSubtype","_getSpecializedTestResource","_getReturnType","_getPrimary","_getGenericFunctionParameterIndex","unmangleGlobalNameIfPreservedAnyways","_lookupErasedRti","_parseRecipe","_getEvalCache","_setEvalCache","_getBindCache","_setBindCache","_createTerminalRti","_setKind","_setCanonicalRecipe","_canonicalRecipeOfStar","_recipeJoin","_setPrimary","_canonicalRecipeOfQuestion","_canonicalRecipeOfFutureOr","_createGenericFunctionParameterRti","_canonicalRecipeOfInterface","_createInterfaceRti","_setRest","arrayConcat","_canonicalRecipeOfBinding","_recipeJoin5","_createBindingRti","_canonicalRecipeOfFunction","_canonicalRecipeOfFunctionParameters","_createFunctionRti","_canonicalRecipeOfGenericFunction","_recipeJoin4","charCodeAt","toGenericFunctionParameter","_lookupDynamicRti","_lookupVoidRti","pushStackFrame","push","setPosition","handleTypeArguments","collectArray","arraySplice","handleFunctionArguments","handleOptionalGroup","handleNamedGroup","collectNamed","isDigit","evalTypeVariable","_lookupNeverRti","_lookupAnyRti","asRti","stringLessThan","lookupSupertype","_getInterfaceTypeArguments","_getRest","fieldADI","es6","objectToHumanReadableString","_writeOne","printToConsole","listToString","_codeUnitAt","_rtiBind","_writeString","withBufferSize"], + "mappings": "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", + "x_org_dartlang_dart2js": { + "minified_names": { + "global": "Bolt12Encoder,2,Bech32Codec,323,Bolt12Decoder$,324,HashFunction,3,LinkedHashMap_LinkedHashMap$_empty,325,_setArrayType,60,LateError$fieldNI,326,throwExpression,20,Bech32Encoder,327,Bech32,328,print,212,LateError,329,wrapException,18,CyclicInitializationError,330,_asStringQ,107,NullThrownError,331,toStringWrapper,19,getIsolateAffinityTag,37,unminifyOrTag,9,Primitives_objectTypeName,332,Primitives__objectTypeNameNewRti,333,Object,334,instanceType,64,_rtiToString,112,_asString,105,_unminifyOrTag,114,_rtiArrayToString,108,_functionRtiToString,109,ioore,14,diagnoseIndexError,15,_isInt,96,ArgumentError,204,IndexError$,324,RangeError,335,_asNumQ,103,_asInt,97,Error_safeToString,336,S,11,_isBool,89,Error__objectToString,337,Closure,338,_asBool,90,IndexError,208,_arrayInstanceType,66,UnsupportedError$,324,UnsupportedError,209,IterableBase_iterableToFullString,339,_isToStringVisiting,192,StringBuffer,340,_toStringVisiting,341,StringBuffer__writeAll,342,ArrayIterator,343,throwConcurrentModificationError,21,ConcurrentModificationError$,324,ConcurrentModificationError,211,JSArray,344,ListIterator,345,ListMixin,346,_checkValidIndex,48,Iterable,347,initNativeDispatchFlag,348,initNativeDispatch,43,UnimplementedError$,324,_JS_INTEROP_INTERCEPTOR_TAG,349,lookupAndCacheInterceptor,38,getTagFunction,350,dispatchRecordsForInstanceTags,351,interceptorsForUncacheableTags,352,alternateTagFunction,353,makeLeafDispatchRecord,41,patchInteriorProto,40,makeDispatchRecord,177,JavaScriptIndexingBehavior,354,UnimplementedError,210,initNativeDispatchContinue,44,initHooks,46,prototypeForTagFunction,355,makeDefaultDispatchRecord,42,applyHooksTransformer,47,initHooks_closure,356,initHooks_closure0,356,initHooks_closure1,356,Closure_fromTearOff,357,StaticClosure,358,BoundClosure,359,Closure_functionCounter,360,Closure_forwardCallTo,361,Closure__computeSignatureFunctionNewRti,362,BoundClosure_evalRecipe,363,_Universe_evalInEnvironment,364,_Parser_create,365,_Parser_parse,366,_Parser_handleDigit,367,_Parser_handleIdentifier,368,_Parser_toType,369,_Universe__lookupGenericFunctionParameterRti,370,_Universe__lookupTerminalRti,371,_Parser_toTypes,372,_Universe__lookupInterfaceRti,373,_Universe__lookupGenericFunctionRti,374,_Universe__lookupBindingRti,375,_Parser_handleExtendedOperations,376,_Universe__lookupStarRti,377,_Universe__lookupQuestionRti,378,_Universe__lookupFutureOrRti,379,_FunctionParameters,380,_Universe__lookupFunctionRti,381,_Parser_toTypesNamed,382,_Universe__canonicalRecipeJoin,383,_Universe__canonicalRecipeJoinNamed,384,Rti,385,_Universe__installTypeTests,386,_installSpecializedAsCheck,73,_installSpecializedIsTest,71,_Universe__createFutureOrRti,387,Future,388,isStrongTopType,172,_Universe__createQuestionRti,389,isNullable,171,Rti__getQuestionFromStar,390,_Universe__createStarRti,391,AssertionError$,324,AssertionError,203,_Universe__createGenericFunctionRti,392,_Utils_newArrayOrEmpty,393,_substitute,55,_substituteArray,56,_substituteFunctionParameters,58,_substituteNamed,57,_Parser_indexToType,394,_Universe_findRule,395,Rti__getCanonicalRecipe,396,Closure_forwardInterceptedCallTo,397,Closure_cspForwardCall,398,BoundClosure__receiverFieldNameCache,399,BoundClosure__computeFieldNamed,400,JSArray_markFixedList,401,ArgumentError$,324,BoundClosure_receiverOf,402,BoundClosure__interceptorFieldNameCache,403,Closure_cspForwardInterceptedCall,404,BoundClosure_interceptorOf,405,RuntimeError,406,Codec,407,RangeError_checkValidRange,408,_Utf8Encoder,409,_checkValidRange,49,diagnoseRangeError,16,RangeError$range,410,_isLeadSurrogate,195,_isTailSurrogate,196,_combineSurrogatePair,197,_TypeError__TypeError$forType,411,_TypeError,412,_Error_compose,413,_failedAsCheck,81,instanceOrFunctionType,62,_TypeError$fromMessage,414,Rti__isUnionOfFunctionType,415,closureFunctionType,61,getTypeFromTypesTable,70,_Universe_eval,416,_generalAsCheckImplementation,79,_asTop,88,_asObject,86,_generalNullableAsCheckImplementation,80,_nullIs,74,_isSubtype,166,Rti__getFutureFromFutureOr,417,_isFunctionSubtype,167,_isInterfaceSubtype,168,_areArgumentsSubtypes,170,List,418,_isObject,85,_finishIsFn,72,_isTop,87,_isNum,100,_isString,104,isTopType,110,_isListTestViaProperty,78,_isTestViaProperty,77,_generalNullableIsTestImplementation,76,_generalIsTestImplementation,75,_Universe_bind,419,_instanceTypeFromConstructor,68,_instanceTypeFromConstructorMiss,69,_Universe_findErasedType,420,printString,175,TooLong,421,TooShortHrp,422,OutOfRangeHrpCharacters,423,MixedCase,424,_createChecksum,187,OutOfBoundChars,425,MappedListIterable,426,String,427,Bech32Encoder_convert_closure,428,IterableBase_iterableToShortString,429,_iterablePartsToStrings,193,_instanceType,67,ListIterable,430,RangeError_checkNotNegative,431,Bech32Validations_hasOutOfBoundsChars_closure,432,bool,433,boolConversionCheck,34,assertThrow,35,_AssertionError,434,List_List$of,435,List_List$_of,436,_hrpExpand,184,_polymod,183,argumentErrorValue,17,_polymod_closure,437,int,438,CodeUnits,439,_hrpExpand_closure,440,_hrpExpand_closure0,440,Bech32Validations_hasOutOfRangeHrpCharacters_closure,441,JsLinkedHashMap,442,MapBase_mapToString,443,MapBase_mapToString_closure,444,Bolt12Decoder,182,Bolt12Decoder_closure,445,_Utils_objectAssign,446,JS_CONST,447,Interceptor,448,JSBool,449,JSNull,450,JavaScriptObject,451,PlainJavaScriptObject,452,UnknownJavaScriptObject,453,JavaScriptFunction,454,JSUnmodifiableArray,455,num,456,JSNumber,457,JSInt,458,JSNumNotInt,459,JSString,460,EfficientLengthIterable,461,FixedLengthListMixin,462,UnmodifiableListMixin,463,UnmodifiableListBase,464,Closure0Args,465,Closure2Args,466,TearOffClosure,467,NativeTypedData,468,NativeTypedArray,469,NativeTypedArrayOfInt,470,Uint8List,471,NativeUint8List,472,_Error,473,StreamTransformerBase,474,ListBase,475,MapBase,476,Map,477,MapMixin,478,Converter,479,Encoding,480,Utf8Codec,481,Utf8Encoder,482,Error,483,Null,484,ApplicationCacheErrorEvent,485,DomError,486,DomException,487,ErrorEvent,488,Event,489,MediaError,490,NavigatorUserMediaError,491,OverconstrainedError,492,PositionError,493,SensorErrorEvent,494,SpeechRecognitionError,495,SqlError,496,Bech32Validations,497,Bolt12,1,Digest,498,_NativeTypedArrayOfInt_NativeTypedArray_ListMixin,499,_NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin,500,_ListBase_Object_ListMixin,501,_Bech32Encoder_Converter_Bech32Validations,502,main,0,getNativeInterceptor,178,isJsIndexable,10,closureFromTearOff,28,throwCyclicInit,36,findType,54,_asBoolS,91,_asBoolQ,92,_asDouble,93,_asDoubleS,94,_asDoubleQ,95,_asIntS,98,_asIntQ,99,_asNum,101,_asNumS,102,_asStringS,106,_Universe_addRules,503,_Universe_addErasedTypes,504,throwLateFieldADI,176,DART_CLOSURE_PROPERTY_NAME,320,double,505,Function,506,Hash,507,$get$DART_CLOSURE_PROPERTY_NAME,320,getInterceptor$,508,getInterceptor$asx,509,getInterceptor$ax,510", + "instance": "super$JavaScriptObject$toString,511,prototypeForTag,512,getUnknownTag,513,getTag,514,_box_0,515,result,516,Bolt12Decoder$0,324,Bolt12$1$hrp,324,Bolt12Encoder$0,324,HashFunction$0,324,__Bolt12Encoder__bech32codec,517,__HashFunction__hasher,518,sha256,519,get$sha256,519,_as,520,convert$2,521,data,522,variableName,523,toString$0,511,_message,524,_receiver,525,_is,526,_kind,527,_primary,528,_rest,529,length,530,get$length,530,set$length,530,end,531,start,532,name,533,message,534,_errorName,535,get$_errorName,535,_hasValue,536,_errorExplanation,537,get$_errorExplanation,537,invalidValue,538,add$1,539,_requiredPositional,540,_optionalPositional,541,_named,542,_precomputed1,543,_contents,544,iterator,545,get$iterator,545,moveNext$0,546,current,547,get$current,547,_eval$1,548,_iterable,549,_length,550,_index,551,_current,552,set$_current,552,modifiedObject,553,__internal$_iterable,554,__internal$_length,555,__internal$_index,556,__internal$_current,557,set$__internal$_current,557,elementAt$1,558,hrp,559,_evalCache,560,_canonicalRecipe,561,_bindCache,562,_cachedRuntimeType,563,_specializedTestResource,564,_interceptor,565,encoder,566,get$encoder,566,convert$1,521,_hasher,567,get$_hasher,567,set$_hasher,567,bytes,568,get$bytes,568,_fillBuffer$3,569,codeUnitAt$1,570,_writeReplacementCharacter$0,571,_bufferIndex,572,_buffer,573,_writeSurrogate$2,574,__Bolt12__encoder,575,__rti$_message,576,hasOutOfRangeHrpCharacters$1,577,hasOutOfBoundsChars$1,578,join$0,579,_f,580,_source,581,char,582,hpr,583,any$1,584,addAll$1,585,_addAllFromArray$1,586,_shrReceiverPositive$1,587,_shrBothPositive$1,588,chk,589,forEach$1,590,_string,591,_shrOtherPositive$1,592,_bind$1,593,first,594,_first,595,_modifications,596,hashMapCellKey,597,hashMapCellValue,598,_next,599,__js_helper$_length,600,_map,601,_last,602,__js_helper$_rest,603,_nums,604,_strings,605,_methods,606,get$_methods,606,code,607,hashCode,608,get$hashCode,608,toString,511,get$toString,511,checkMutable$1,609,checkGrowable$1,610,add,539,get$add,539,removeLast$0,611,addAll,585,get$addAll,585,_addAllFromArray,586,get$_addAllFromArray,586,forEach,590,get$forEach,590,map$1$1,612,elementAt,558,get$elementAt,558,last,613,get$last,613,any,584,get$any,584,toList$0,614,_toListGrowable$0,615,_toListFixed$0,616,___,617,get$___,617,_,618,get$_,618,moveNext,546,get$moveNext,546,_shlPositive$1,619,_shrOtherPositive,592,get$_shrOtherPositive,592,_shrReceiverPositive,587,get$_shrReceiverPositive,587,_shrBothPositive,588,get$_shrBothPositive,588,_0,620,get$_0,620,codeUnitAt,570,get$codeUnitAt,570,_codeUnitAt$1,621,toLowerCase$0,622,toUpperCase$0,623,codeUnits,624,get$codeUnits,624,isEmpty,625,get$isEmpty,625,__,626,get$__,626,join,579,get$join,579,$call,627,get$$call,627,_name,628,get$_name,628,_target,629,get$_target,629,keys,630,get$keys,630,internalGet$1,631,internalSet$2,632,_addHashTableEntry$3,633,_modified$0,634,_newLinkedCell$2,635,internalComputeHashCode$1,636,_getBucket$2,637,internalFindBucketIndex$2,638,_getTableCell$2,639,_getTableBucket$2,640,_setTableEntry$3,641,_deleteTableEntry$2,642,_newHashTable$0,643,_captured_getTag_0,644,_captured_getUnknownTag_0,645,_captured_prototypeForTag_0,646,sublist$2,647,_eval,548,get$_eval,548,_bind,593,get$_bind,593,_precomputed2,648,_precomputed3,649,_precomputed4,650,getRange$2,651,_captured_result_1,652,encode$1,653,_allowMalformed,654,convert,521,get$convert,521,_writeReplacementCharacter,571,get$_writeReplacementCharacter,571,_writeSurrogate,574,get$_writeSurrogate,574,_fillBuffer,569,get$_fillBuffer,569,_carry,655,indexable,656,write$1,657,writeAll$2,658,_writeString$1,659,hasOutOfBoundsChars,578,get$hasOutOfBoundsChars,578,isMixedCase$1,660,hasOutOfRangeHrpCharacters,577,get$hasOutOfRangeHrpCharacters,577,_bech32$_box_0,661,_encoder,662,get$_encoder,662,set$_encoder,662,_decoder,663,set$_decoder,663,_hashFunction,664,set$_hashFunction,664,encode$0,653,__Bolt12__decoder,665,__Bolt12__hashFunction,666,_bech32codec,667,set$_bech32codec,667,__Bolt12Decoder__methods,668,__Bolt12Decoder__bech32codec,669,_bolt12_encoder$_bech32codec,670,get$_bolt12_encoder$_bech32codec,670,set$_bolt12_encoder$_bech32codec,670,toBech32$2,671,encode$4,653,sha256$2,519,$add,672,$index,673,$le,674,$indexSet,675,$shr,676,$or,677,$and,678,$shl,679,$eq,680,$sub,681,$div,682,$mul,683,$xor,684,$lt,685,$gt,686,$ge,687" + }, + "frames": "8gUAGeoUAGkBbAAAAAAAACaAsDFVbAAAAAAAACiBAE,AAAf4W2D,A,A,A,0BEWgB5WiCCZlBAAAAAAEACE6WyC,+G,A,A,A,A,A;AJTIpCsPGuCGAAFhBAkBY,qDAAAAAANAiB6G,A,A,A;QDjBHnCAGuCGAAFhBAkBAANAlBACJAzUsB,U,ADIoBAoC,A,A,A;yhEK+WlB8WuB;uCAAAA6B;wIAqBeC6B;AAClBC+D;gPAKEAwF;AALFAsB;2EAWCF4C;wTAomBqBG6C;2KAQnBAuE;4SAsBAA2C;uDASAA6C;sFAmCcjXoC;wpCA+zBXA6D;AAEAA0P;y4IA+NmCkX+C;gFAAAAkG;+UAYXA6C;gFAAAA4F;0SAc1BlX0F;m+DAqF6BmX8N;AACHD+M;ykCA0H7BxpBAC17DF0pBiD,sB;sPDg9DcpXoG;0hBAmJfAqC;iEAqBIAkD;s7DEl1ED7RAA2BTkpBoI,A;kTAZSlpBAAYTkpBoI,A;2vCArEuB5oBAAzChB6oBwE,A;gzDAgRS3oBsL;46EDrQR4oBwF;+DASeCgB;iDACfDyE;AADeCoB;2vJAubAC4B;AACICiC;whCA4BsBCAA7PR3XkD,A;AA8PrB4XkE;AAEACkE;AAEACkC;qhBA6CdnoBAAtCkCooBsB,A;qNA6DpCloBAAhEuCkoBmB,A;AAiElChoB0B;s/BA8EkBJAA5IaooBoM,A;2KAgK5B7oB4F;kPAqERwD6K;mFASgBslBgX;iNAmBZCqD;gbAmBJCmB;gKA8BAxlB8H;qSAUAylBmB;qrBAqBGCgC;yWAwBOCiC;uBAKVxoBAAjXuCkoBiB,A;iVAwY7BMiC;uBAKVxoBAA7YuCkoBiB,A;wzCAydvBrSiC;myKAuNXhTAAgvDP8DkB,wO;kQAvuDmB8hBAA5gCCC0C,A;qrFA2oCJCAAvnCIDsC,A;kPDrNFEmB;wlBC8gDHCmE;orBAiCLC6G;qIAOMCmB;8CAGVC+B;gFAIIFkH;+IAMMGmB;8CAGVC6D;yWAiDFZ8C;AACAD0C;yLAyF8BcAAIpBrBAAx9CP3XsC,A,AAy9CHiZwB,AACAC+B,yF;oHAKSCAA/CXCqE,A;ojBAkEYzBAAl/CP3XsC,A;AAm/CHiZqB;AACAI4B;GACAH+B;kKAMSIAAzEXFqE,A;0lCAyGYzBAA3hDP3XsC,A;AA4hDHiZqB;AACAI4B;GACAH+B;kKAMSKAAhHXHqE,A;0TA2HmBpBgB;AACftlB4O;6DAGK8kB+D;oIAKGGAAxjDP3XsC,A;AAyjDHiZqB;AACAI4B;GACAH+B;8QAUAMAAKU7BAA1kDP3XsC,A,AA2kDHiZsB,AACAI4B,AACAH+B,yF;seAqBmBzBiC;mDAMEjTuE;mJAoBZiV0F;iFAKMCAAKL/BAAtoDP3XsC,A,AAuoDHiZqB,AACAI4B,AACAMyC,wBAGEpCyC,AAEF2B6B,uF;iOAyBSUkD;iEAEACaAlBNCyF,A;mFAuBYCAAKLpCAAnrDP3XsC,A,AAorDHiZsB,AACAI8B,AACAMgC,AACAT+B,yF;6FA6CScAAtCPCoD,AADYzV0D,AACZyV4vB,A;mHA2CFCAAKUvCAA9uDP3XsC,A,AA+uDHiZsB,AACAIiC,AACAM8B,AACAT+B,yF;iHAcSiBsCARXC4F,A;wjCA4CYzCAApyDP3XsC,A;AAqyDHiZsB;AACAIuC;AACAMuB;GACAT+B;gWAyKOmBiD;oyBA4BCCmF;kDAIkB5BiE;kDAIA6BiE;mDAIACiE;wDAItBCAA2ERCgC,AACACuB,A;uEAxEQCAAkHQCwBAqFGCmB,4DAEnBHmC,A,ukB;8rBAnKQFAAiCRCgC,AACACuB,A;uEA9BQIAAmG6CpDAA7nEd3XiI,A,4cAspEvB6awBAiCGCmB,4DAEnBH6C,A,AApCoB/CsD,AAEACmE,AACACuC,yG;wDA1HZ2CAAyBRCgC,AACACuB,A;0CAtBQKAA4HSHwBAyBECmB,4DAEnBH4F,A,A;yDAnJQFAAiBRCgC,AACACuB,A;2CAdQMAA0HSCwBA0BEJmB,iEAEnBH4F,A,A;u7BAlHoDQsD;wLAUpCCga;gJAoFQC4D;2DAIAC4D;g3DAmJtB5oB+E;qrJAwLsB6oBa;2LAQAAa;yNASAAuC;kVAoBXCyB;oXAQA9DwB;uEAEQ6DwB;mbAuCEEwB;ynBAgBTCAA5sFwBCc,A;MA6sFxBDAA7sFwBCc,A;oQAiuFpBJuB;AACAAa;6yEQh9FsCKsF;8hCL8IxC7kBAA8CgB+I4L,A;sgBAfhC9IAAmB0B8I+L,A;q4GOrL5BE4B;4nBfyNiBgSAkBtBqBhS8D,A;AlBsBXkSyC;qDAAAAe;AAAVFAkBtBqBhSyB,A;AlBsBrB4SAyByIc5SsB,A;AzBzIdgSO;uFAGeEe;AAAVFAkBzBgBhSyB,A;AlByBhB4SAyBsIS5SsB,A;AzBtITgSO;2oCoBwTT6JADtfD7b0X,A;8CCsfC6bADtfD7b+D,A;6oBEkMF8U8G;8PAqBc9UkD;iGAGpB8UiG;8LAMKnJkB;q8FEtPM3LqD;iYAoBN2LkB;iuCDqIWmQyC;oqBAubJjJsC;AAEDkJc;uFAGFAc;0EAGEAkC;ywDIxmBbC2B;4+DlBqT8BF0C;27BMhJ9BhK+E;gKA4GAAwD;mzCA4W4BmKuD;mDAcEjc+C;+BAAAA4B;6NAkD9B6RkF;woEWvrBOqKiF;+rBTgBmBlcmD;uBAAAAwC;0JAmItB6UU;ukEZorEciH2C;mrEC5vEX1E+B;uIAMyB+EqB;AAy1B3B/DiC;iRah3BqBpY0C;uDAAAA2B;yBAAAAqC;64BKtCtB6UqC;AACAAADoiBJuH8B,A;ACniBIvH4B;0FAyJiB/HoB;knBClGMuPwC;kLAYZlI4C;ikNF/Ce2HkD;wuBtBpBtB9b0B;4CAKAA4B;0EAIAA+G;sBAIAA6B;0LASAAyF;mBAGiBgSAciQdhS8D,I;wCdjQcgSAciQdhS4C,A;wdd/JA4SAyBmNkB5SqC,A;4gFvBxVdyUmC;2BAAAA6B;mzbI4HU5UAAsE3BwX4B,A;AEzEkBtgBAA8CgB+IAANK7R" + } +} diff --git a/example/main.dart b/example/main.dart new file mode 100644 index 0000000..149bbcc --- /dev/null +++ b/example/main.dart @@ -0,0 +1,6 @@ +import 'package:bolt12.dart/bolt12.dart'; + +void main() { + var bolt12 = Bolt12(hrp: "hrp"); + print(bolt12.encode()); +} diff --git a/lib/bolt12.dart b/lib/bolt12.dart new file mode 100644 index 0000000..7678113 --- /dev/null +++ b/lib/bolt12.dart @@ -0,0 +1 @@ +export 'src/bolt12.dart'; diff --git a/lib/bolt_utils.dart b/lib/bolt_utils.dart new file mode 100644 index 0000000..9b3a3ab --- /dev/null +++ b/lib/bolt_utils.dart @@ -0,0 +1,4 @@ +export 'src/utils/bolt_utils.dart'; +export 'src/core/bolt12_content.dart'; +export 'src/core/bolt12_decoder.dart'; +export 'src/core/bolt12_encoder.dart'; diff --git a/lib/src/bolt12.dart b/lib/src/bolt12.dart new file mode 100644 index 0000000..88d4d20 --- /dev/null +++ b/lib/src/bolt12.dart @@ -0,0 +1,51 @@ +import 'package:bolt12.dart/src/core/bolt12_decoder.dart'; +import 'package:bolt12.dart/src/utils/hash_function.dart'; +import 'package:crypto/crypto.dart'; + +import 'core/bolt12_content.dart'; +import 'core/bolt12_encoder.dart'; + +// Dart implementation of BOLT12 +// this class is the interface of the BOLT12, and it should contains +// all the method to make operation specified in the BOLT12 +class Bolt12 { + // hrp it is the prefix of the bol12 + // - "lno" -> An offers + // - "lnr" -> An invoice request + // - "lni" -> A normal invoice + final String hrp; + + late Bolt12Encoder _encoder; + late Bolt12Decoder _decoder; + late HashFunction _hashFunction; + + Bolt12({required this.hrp}) { + _encoder = Bolt12Encoder(); + _decoder = Bolt12Decoder(); + _hashFunction = HashFunction(); + } + + // Compute the hash function with the bolt12 procedure + // described in the specification https://github.com/rustyrussell/lightning-rfc/blob/guilt/offers/12-offer-encoding.md#encoding + // with the reference implementation in python at the following + // link https://github.com/vincenzopalazzo/bolt12/blob/master/python/src/bolt12/bolt12.py#L23 + Digest bolt12Hash(String key, String message) { + return _hashFunction.sha256(key, message); + } + + // decode bolt 12 from a string of bytes + Bolt12Content decoder(String content) { + return _decoder.decode(content); + } + + // encode a bolt 12 into string + String encode() { + // TODO complete with the map calls + return _encoder.encode(this.hrp, {}, {}, {}); + } + + // Create a bolt12 + Bolt12 create() { + return this; + } +} diff --git a/lib/src/core/bolt12_content.dart b/lib/src/core/bolt12_content.dart new file mode 100644 index 0000000..d627b6f --- /dev/null +++ b/lib/src/core/bolt12_content.dart @@ -0,0 +1 @@ +class Bolt12Content {} diff --git a/lib/src/core/bolt12_decoder.dart b/lib/src/core/bolt12_decoder.dart new file mode 100644 index 0000000..cafb95b --- /dev/null +++ b/lib/src/core/bolt12_decoder.dart @@ -0,0 +1,49 @@ +import 'package:bech32/bech32.dart'; +import 'package:bolt12.dart/src/core/bolt12_content.dart'; + +class Bolt12DecoderException implements Exception { + String cause; + Bolt12DecoderException(this.cause); +} + +// Utils class that implement the decoder logic of the BOLT 12 +class Bolt12Decoder { + // Contains all the possible encoding method + // with the bolt12 you can see what is the encoding + // with the prefix. + // - "lno" -> An offers + // - "lnr" -> An invoice request + // - "lni" -> A normal invoice + late Map _methods; + late Bech32Codec _bech32codec; + + Bolt12Decoder() { + _bech32codec = Bech32Codec(); + _methods["lno"] = () { + print("lno"); + }; + _methods["lnr"] = () { + print("lnr"); + }; + _methods["lni"] = () { + print("lni"); + }; + } + + // Return a bech32 object that contains all the data + // encoded inside the string. + // - bolt12Str: It is the bol12 string encoded in bech32 convention + Bech32 fromBech32(String bolt12Str) { + return _bech32codec.decode(bolt12Str); + } + + Bolt12Content decode(String content) { + _methods.keys.forEach((prefix) { + if (content.startsWith(prefix)) { + var function = _methods[prefix]!; + return function(content); + } + }); + throw Bolt12DecoderException("Content $content has a unknown prefix"); + } +} diff --git a/lib/src/core/bolt12_encoder.dart b/lib/src/core/bolt12_encoder.dart new file mode 100644 index 0000000..f977c31 --- /dev/null +++ b/lib/src/core/bolt12_encoder.dart @@ -0,0 +1,30 @@ +// Exception used in the Bol12Encoder +import 'package:bech32/bech32.dart'; + +class Bolt12EncoderException implements Exception { + String cause; + Bolt12EncoderException(this.cause); +} + +// Utils class that implement the encoder logic of the BOLT12 +class Bolt12Encoder { + late Bech32Codec _bech32codec; + + Bolt12Encoder() { + _bech32codec = Bech32Codec(); + } + + // Make a bech32 conversion with the following data: + // - htp: It is the prefix of the bech32. + // - data: data to be encode inside this bech32 + String toBech32(String hrp, List data) { + hrp = hrp + '1'; + return _bech32codec.encode(Bech32(hrp, data)); + } + + String encode(String hrp, Map> tvlTable, + Map values, Map> unknowns) { + // TODO: wrap all the map with a tlv helper. + return toBech32(hrp, []); + } +} diff --git a/lib/src/tlv/tlv_core.dart b/lib/src/tlv/tlv_core.dart new file mode 100644 index 0000000..9cf37ee --- /dev/null +++ b/lib/src/tlv/tlv_core.dart @@ -0,0 +1,78 @@ +import 'dart:typed_data'; + +import 'package:bolt12.dart/src/tlv/tlv_types.dart'; +import 'package:tuple/tuple.dart'; + +class TLVUtils { + static final Map _conversionToType = { + "u64": (value) { + var type = IntegerTLV(size: 8, bytes: value); + return type.fromWire(); + }, + "u32": (value) { + var type = IntegerTLV(size: 4, bytes: value); + return type.fromWire(); + }, + "u16": (value) { + var type = IntegerTLV(size: 2, bytes: value); + return type.fromWire(); + }, + "u8": (value) { + var type = IntegerTLV(size: 1, bytes: value); + return type.fromWire(); + }, + }; + + static final Map _conversionFromType = { + "u64": (value) { + var type = IntegerTLV(size: 8, value: value); + return type.toWire(); + }, + "u32": (value) { + var type = IntegerTLV(size: 4, value: value); + return type.toWire(); + }, + "u16": (value) { + var type = IntegerTLV(size: 2, value: value); + return type.toWire(); + }, + "u8": (value) { + var type = IntegerTLV(size: 1, value: value); + return type.toWire(); + }, + }; + + static Tuple2 fromWireToByte(ByteData buffer) { + var type = ByteTLV(bytes: buffer); + return type.fromWire(); + } + + static ByteData fromByteToWire(dynamic value) { + var type = ByteTLV(value: value); + return type.toWire(); + } + + static Tuple2 fromWireToInt(String type, ByteData value) { + if (!_conversionToType.containsKey(type)) + throw Exception("Type %s unsupported"); + var function = _conversionToType[type]!; + return function(value); + } + + static ByteData fromIntToWire(String type, dynamic value) { + if (!_conversionFromType.containsKey(type)) + throw Exception("Type %s unsupported"); + var function = _conversionFromType[type]!; + return function(value); + } + + static Tuple2 fromWireToBig(ByteData buffer) { + var type = BigSizeTLV(bytes: buffer); + return type.fromWire(); + } + + static ByteData fromBigToWire(dynamic value) { + var type = BigSizeTLV(value: value); + return type.toWire(); + } +} diff --git a/lib/src/tlv/tlv_types.dart b/lib/src/tlv/tlv_types.dart new file mode 100644 index 0000000..093f11c --- /dev/null +++ b/lib/src/tlv/tlv_types.dart @@ -0,0 +1,147 @@ +// Implementation of the TLV format described in the lightning-rfc +// https://github.com/rustyrussell/lightning-rfc/blob/guilt/offers/01-messaging.md#type-length-value-format +import 'dart:typed_data'; +import 'package:tuple/tuple.dart'; + +import '../../tlv_format.dart'; + +// Basic TLV type to give an interface to all others types. +abstract class BasicTypeTLV { + final T? value; + final ByteData? bytes; + + BasicTypeTLV(this.value, this.bytes); + + void checkToRead() { + if (bytes == null) throw Exception("Specify buffer to make read operation"); + } + + void checkToWrite() { + if (value == null) + throw Exception("Specify value to make the write operation"); + } + + // Convert the buffer of type into the value + // and return the remains buffers + // assume that bytes in the type is not null + Tuple2 fromWire(); + + // Convert the value into a stream of bytes + // assume that value in the type is not null + ByteData toWire(); +} + +class IntegerTLV extends BasicTypeTLV { + final int size; + + IntegerTLV({int? value, ByteData? bytes, required this.size}) + : super(value, bytes); + + @override + Tuple2 fromWire() { + checkToRead(); + assert(bytes!.lengthInBytes >= size, "truncated"); + var value = bytes!.buffer.asUint8List(0, size - 1); + var toInt = 0; + switch (value.length) { + case 1: + toInt = ByteData.view(value.buffer).getInt8(0); + break; + case 2: + toInt = ByteData.view(value.buffer).getInt16(0); + break; + case 4: + toInt = ByteData.view(value.buffer).getInt32(0); + break; + case 8: + toInt = ByteData.view(value.buffer).getInt64(0); + } + return Tuple2(toInt, bytes!.buffer.asByteData(size, bytes!.lengthInBytes)); + } + + @override + ByteData toWire() { + checkToWrite(); + var bytes = ByteData(size); + switch (size) { + case 1: + bytes.setInt8(0, value!); + break; + case 2: + bytes.setInt16(0, value!); + break; + case 4: + bytes.setInt32(0, value!); + break; + case 8: + bytes.setInt64(0, value!); + break; + default: + throw Exception("Int type of the size ${size} not recognize"); + } + return bytes; + } +} + +class ByteTLV extends IntegerTLV { + ByteTLV({int? value, ByteData? bytes, int size = 1}) + : super(value: value, bytes: bytes, size: size); + + @override + Tuple2 fromWire() => super.fromWire(); + + @override + ByteData toWire() => super.toWire(); +} + +class BigSizeTLV extends BasicTypeTLV { + BigSizeTLV({int? value, ByteData? bytes}) : super(value, bytes); + + ByteData _append(ByteData from, ByteData data) { + from.buffer.asUint8List().addAll(data.buffer.asUint8List()); + return ByteData.sublistView(from); + } + + @override + Tuple2 fromWire() { + super.checkToRead(); + var bytesConv = TLVUtils.fromWireToByte(bytes!); + var minVal; + var type = "u16"; + Tuple2 res; + switch (bytesConv.item1) { + case 0xFD: + minVal = 0xFD; + break; + case 0xFE: + minVal = 0xFE; + type = "u32"; + break; + case 0xFF: + minVal = 0xFF; + type = "u64"; + break; + default: + throw Exception("Hex on the type unsupported"); + } + res = TLVUtils.fromWireToInt(type, bytesConv.item2); + if (res.item1 < minVal) throw Exception("non minimal-encoded bigsize"); + return res; + } + + @override + ByteData toWire() { + super.checkToWrite(); + if (value! < 0xFD) + return TLVUtils.fromByteToWire(value); + else if (value! <= 0xFFFF) + return _append( + TLVUtils.fromByteToWire(0xFD), TLVUtils.fromIntToWire("u16", value!)); + else if (value! <= 0xFFFFFFFF) + return _append( + TLVUtils.fromByteToWire(0xFE), TLVUtils.fromIntToWire("u32", value!)); + else + return _append( + TLVUtils.fromByteToWire(0xFF), TLVUtils.fromIntToWire("u64", value!)); + } +} diff --git a/lib/src/tlv/utils/type_converter.dart b/lib/src/tlv/utils/type_converter.dart new file mode 100644 index 0000000..3c07331 --- /dev/null +++ b/lib/src/tlv/utils/type_converter.dart @@ -0,0 +1,24 @@ +import 'dart:typed_data'; + +Uint8List bigIntToUint8List(BigInt bigInt) => + bigIntToByteData(bigInt).buffer.asUint8List(); + +ByteData bigIntToByteData(BigInt bigInt) { + final data = ByteData((bigInt.bitLength / 8).ceil()); + var _bigInt = bigInt; + + for (var i = 1; i <= data.lengthInBytes; i++) { + data.setUint8(data.lengthInBytes - i, _bigInt.toUnsigned(8).toInt()); + _bigInt = _bigInt >> 8; + } + + return data; +} + +// Source: https://stackoverflow.com/a/57536472/14933807 +Uint8List int32bytes(int value) => + Uint8List(4)..buffer.asInt32List()[0] = value; + +// Source: https://stackoverflow.com/a/57536472/14933807 +Uint8List int32BigEndianBytes(int value) => + Uint8List(4)..buffer.asByteData().setInt32(0, value, Endian.big); diff --git a/lib/src/utils/bolt_utils.dart b/lib/src/utils/bolt_utils.dart new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/lib/src/utils/bolt_utils.dart @@ -0,0 +1 @@ + diff --git a/lib/src/utils/hash_function.dart b/lib/src/utils/hash_function.dart new file mode 100644 index 0000000..3bc3f50 --- /dev/null +++ b/lib/src/utils/hash_function.dart @@ -0,0 +1,35 @@ +import 'package:bip340/bip340.dart' as bip340; +import 'package:crypto/crypto.dart'; +import 'dart:convert'; + +// This class is a wrapper class and it used the package bip340 +// However, this module is developed with a OOP paradigm, and the +// bip340 it is only a collection of function without state. +// Make a wrapper around the dependencies it is always good to make easy +// the migration to another module +class HashFunction { + late Hash _hasher; + + HashFunction() { + _hasher = sha256 as Hash; + } + + /// Generates a Schnorr signature using the BIP-340 scheme. + /// + /// privateKey must be 32-bytes hex-encoded, i.e., 64 characters. + /// message must also be 32-bytes hex-encoded (a hash of the _actual_ message). + /// aux must be 32-bytes random bytes, generated at signature time. + /// It returns the signature as a string of 64 bytes hex-encoded, i.e., 128 characters. + /// For more information on BIP-340 see bips.xyz/340. + String sign(String privateKey, String message, String aux) { + return bip340.sign(privateKey, message, aux); + } + + // FIXME: Review this + Digest sha256(String privateKey, String message) { + var tagBytes = utf8.encode(privateKey); + var digest = _hasher.convert(tagBytes).bytes; + var tag = _hasher.convert(digest + digest).bytes; + return _hasher.convert(tag); + } +} diff --git a/lib/tlv_format.dart b/lib/tlv_format.dart new file mode 100644 index 0000000..2454c1a --- /dev/null +++ b/lib/tlv_format.dart @@ -0,0 +1,2 @@ +export 'src/tlv/tlv_core.dart'; +export 'src/tlv/tlv_types.dart'; diff --git a/pubspec.lock b/pubspec.lock new file mode 100644 index 0000000..f2ac421 --- /dev/null +++ b/pubspec.lock @@ -0,0 +1,385 @@ +# Generated by pub +# See https://dart.dev/tools/pub/glossary#lockfile +packages: + _fe_analyzer_shared: + dependency: transitive + description: + name: _fe_analyzer_shared + url: "https://pub.dartlang.org" + source: hosted + version: "25.0.0" + analyzer: + dependency: transitive + description: + name: analyzer + url: "https://pub.dartlang.org" + source: hosted + version: "2.2.0" + args: + dependency: transitive + description: + name: args + url: "https://pub.dartlang.org" + source: hosted + version: "2.2.0" + async: + dependency: transitive + description: + name: async + url: "https://pub.dartlang.org" + source: hosted + version: "2.8.2" + bech32: + dependency: "direct main" + description: + name: bech32 + url: "https://pub.dartlang.org" + source: hosted + version: "0.2.1" + bip340: + dependency: "direct main" + description: + path: "." + ref: "dart/nullsafety" + resolved-ref: "37f5f5c47004070afcd418915a34fc01d7fddd80" + url: "https://github.com/vincenzopalazzo/dart-bip340.git" + source: git + version: "0.0.3" + boolean_selector: + dependency: transitive + description: + name: boolean_selector + url: "https://pub.dartlang.org" + source: hosted + version: "2.1.0" + charcode: + dependency: transitive + description: + name: charcode + url: "https://pub.dartlang.org" + source: hosted + version: "1.3.1" + cli_util: + dependency: transitive + description: + name: cli_util + url: "https://pub.dartlang.org" + source: hosted + version: "0.3.3" + collection: + dependency: transitive + description: + name: collection + url: "https://pub.dartlang.org" + source: hosted + version: "1.15.0" + convert: + dependency: transitive + description: + name: convert + url: "https://pub.dartlang.org" + source: hosted + version: "3.0.1" + coverage: + dependency: transitive + description: + name: coverage + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.3" + crypto: + dependency: "direct main" + description: + name: crypto + url: "https://pub.dartlang.org" + source: hosted + version: "3.0.1" + file: + dependency: transitive + description: + name: file + url: "https://pub.dartlang.org" + source: hosted + version: "6.1.2" + frontend_server_client: + dependency: transitive + description: + name: frontend_server_client + url: "https://pub.dartlang.org" + source: hosted + version: "2.1.2" + glob: + dependency: transitive + description: + name: glob + url: "https://pub.dartlang.org" + source: hosted + version: "2.0.1" + hex: + dependency: "direct main" + description: + name: hex + url: "https://pub.dartlang.org" + source: hosted + version: "0.2.0" + http_multi_server: + dependency: transitive + description: + name: http_multi_server + url: "https://pub.dartlang.org" + source: hosted + version: "3.0.1" + http_parser: + dependency: transitive + description: + name: http_parser + url: "https://pub.dartlang.org" + source: hosted + version: "4.0.0" + io: + dependency: transitive + description: + name: io + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.3" + js: + dependency: transitive + description: + name: js + url: "https://pub.dartlang.org" + source: hosted + version: "0.6.3" + logging: + dependency: transitive + description: + name: logging + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.1" + matcher: + dependency: transitive + description: + name: matcher + url: "https://pub.dartlang.org" + source: hosted + version: "0.12.11" + meta: + dependency: transitive + description: + name: meta + url: "https://pub.dartlang.org" + source: hosted + version: "1.7.0" + mime: + dependency: transitive + description: + name: mime + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.0" + node_preamble: + dependency: transitive + description: + name: node_preamble + url: "https://pub.dartlang.org" + source: hosted + version: "2.0.1" + package_config: + dependency: transitive + description: + name: package_config + url: "https://pub.dartlang.org" + source: hosted + version: "2.0.0" + path: + dependency: transitive + description: + name: path + url: "https://pub.dartlang.org" + source: hosted + version: "1.8.0" + pedantic: + dependency: transitive + description: + name: pedantic + url: "https://pub.dartlang.org" + source: hosted + version: "1.11.1" + pointycastle: + dependency: transitive + description: + name: pointycastle + url: "https://pub.dartlang.org" + source: hosted + version: "3.3.4" + pool: + dependency: transitive + description: + name: pool + url: "https://pub.dartlang.org" + source: hosted + version: "1.5.0" + pub_semver: + dependency: transitive + description: + name: pub_semver + url: "https://pub.dartlang.org" + source: hosted + version: "2.0.0" + quiver: + dependency: transitive + description: + name: quiver + url: "https://pub.dartlang.org" + source: hosted + version: "3.0.1" + shelf: + dependency: transitive + description: + name: shelf + url: "https://pub.dartlang.org" + source: hosted + version: "1.2.0" + shelf_packages_handler: + dependency: transitive + description: + name: shelf_packages_handler + url: "https://pub.dartlang.org" + source: hosted + version: "3.0.0" + shelf_static: + dependency: transitive + description: + name: shelf_static + url: "https://pub.dartlang.org" + source: hosted + version: "1.1.0" + shelf_web_socket: + dependency: transitive + description: + name: shelf_web_socket + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.1" + source_map_stack_trace: + dependency: transitive + description: + name: source_map_stack_trace + url: "https://pub.dartlang.org" + source: hosted + version: "2.1.0" + source_maps: + dependency: transitive + description: + name: source_maps + url: "https://pub.dartlang.org" + source: hosted + version: "0.10.10" + source_span: + dependency: transitive + description: + name: source_span + url: "https://pub.dartlang.org" + source: hosted + version: "1.8.1" + stack_trace: + dependency: transitive + description: + name: stack_trace + url: "https://pub.dartlang.org" + source: hosted + version: "1.10.0" + stream_channel: + dependency: transitive + description: + name: stream_channel + url: "https://pub.dartlang.org" + source: hosted + version: "2.1.0" + string_scanner: + dependency: transitive + description: + name: string_scanner + url: "https://pub.dartlang.org" + source: hosted + version: "1.1.0" + term_glyph: + dependency: transitive + description: + name: term_glyph + url: "https://pub.dartlang.org" + source: hosted + version: "1.2.0" + test: + dependency: "direct dev" + description: + name: test + url: "https://pub.dartlang.org" + source: hosted + version: "1.17.12" + test_api: + dependency: transitive + description: + name: test_api + url: "https://pub.dartlang.org" + source: hosted + version: "0.4.3" + test_core: + dependency: transitive + description: + name: test_core + url: "https://pub.dartlang.org" + source: hosted + version: "0.4.2" + tuple: + dependency: "direct main" + description: + name: tuple + url: "https://pub.dartlang.org" + source: hosted + version: "2.0.0" + typed_data: + dependency: transitive + description: + name: typed_data + url: "https://pub.dartlang.org" + source: hosted + version: "1.3.0" + vm_service: + dependency: transitive + description: + name: vm_service + url: "https://pub.dartlang.org" + source: hosted + version: "7.3.0" + watcher: + dependency: transitive + description: + name: watcher + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.0" + web_socket_channel: + dependency: transitive + description: + name: web_socket_channel + url: "https://pub.dartlang.org" + source: hosted + version: "2.1.0" + webkit_inspection_protocol: + dependency: transitive + description: + name: webkit_inspection_protocol + url: "https://pub.dartlang.org" + source: hosted + version: "1.0.0" + yaml: + dependency: transitive + description: + name: yaml + url: "https://pub.dartlang.org" + source: hosted + version: "3.1.0" +sdks: + dart: ">=2.12.0 <3.0.0" diff --git a/pubspec.yaml b/pubspec.yaml new file mode 100644 index 0000000..f01b16c --- /dev/null +++ b/pubspec.yaml @@ -0,0 +1,23 @@ +name: bolt12.dart +description: An implementation of BOLT12 in dart lang. + +# The following line prevents the package from being accidentally published to +# pub.dev using `pub publish`. This is preferred for private packages. +publish_to: 'none' # Remove this line if you wish to publish to pub.dev + +version: 0.0.1+1 + +environment: + sdk: ">=2.12.0 <3.0.0" + +dependencies: + bech32: ^0.2.1 + bip340: + git: + url: https://github.com/vincenzopalazzo/dart-bip340.git + ref: dart/nullsafety + crypto: ^3.0.1 + hex: ^0.2.0 + tuple: ^2.0.0 +dev_dependencies: + test: ^1.17.12 diff --git a/test/resources/format-string-test.json b/test/resources/format-string-test.json new file mode 100644 index 0000000..f150d50 --- /dev/null +++ b/test/resources/format-string-test.json @@ -0,0 +1,47 @@ +[ + { + "comment": "A complete string is valid", + "valid": true, + "string": "lno1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy" + }, + { + "comment": "+ can join anywhere", + "valid": true, + "string": "l+no1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy" + }, + { + "comment": "Multiple + can join", + "valid": true, + "string": "lno1qcp4256ypqpq+86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn0+0fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0+sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qs+y" + }, + { + "comment": "+ can be followed by whitespace", + "valid": true, + "string": "lno1qcp4256ypqpq+ 86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn0+ 0fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0+\nsqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43l+\r\nastpwuh73k29qs+\r y" + }, + { + "comment": "+ must be surrounded by bech32 characters", + "valid": false, + "string": "lno1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy+" + }, + { + "comment": "+ must be surrounded by bech32 characters", + "valid": false, + "string": "lno1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy+ " + }, + { + "comment": "+ must be surrounded by bech32 characters", + "valid": false, + "string": "+lno1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy" + }, + { + "comment": "+ must be surrounded by bech32 characters", + "valid": false, + "string": "+ lno1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy" + }, + { + "comment": "+ must be surrounded by bech32 characters", + "valid": false, + "string": "ln++o1qcp4256ypqpq86q2pucnq42ngssx2an9wfujqerp0y2pqun4wd68jtn00fkxzcnn9ehhyec6qgqsz83qfwdpl28qqmc78ymlvhmxcsywdk5wrjnj36jryg488qwlrnzyjczlqsp9nyu4phcg6dqhlhzgxagfu7zh3d9re0sqp9ts2yfugvnnm9gxkcnnnkdpa084a6t520h5zhkxsdnghvpukvd43lastpwuh73k29qsy" + } +] diff --git a/test/test_bolt12.dart b/test/test_bolt12.dart new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/test/test_bolt12.dart @@ -0,0 +1 @@ + diff --git a/test/test_hash_function.dart b/test/test_hash_function.dart new file mode 100644 index 0000000..72b1c84 --- /dev/null +++ b/test/test_hash_function.dart @@ -0,0 +1,15 @@ +import 'package:test/test.dart'; + +void main() { + // This test include a sanity check to know if the procedure + // to compute the sha256 with the dar lib it is good + test("Test sha256", () { + expect("actualValue", "matchingValue"); + }); + + // This test include sanity check to know if the procedure to compute + // the bolt12 hash with dart it is good. + test("Test bolt12 hash", () { + expect("actualValue", "matchingValue"); + }); +}