X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=bip39-standalone.html;h=a00cb688c5fad5cb6a411bbd41a76e8b843b89e3;hb=534481b628cd6d9172b236c8b6b4ef7fab4e0f29;hp=961bedb2dd53168cacf2deb5514f05798e4e81ce;hpb=01e81e53aef6e7d57ef2f342337ea7723bf41a2f;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git diff --git a/bip39-standalone.html b/bip39-standalone.html index 961bedb..a00cb68 100644 --- a/bip39-standalone.html +++ b/bip39-standalone.html @@ -107,12 +107,18 @@ border-bottom: 1px dashed #000; text-decoration: none; } + .version { + position: absolute; + top: 5px; + right: 5px; + }

Mnemonic Code Converter

+

v0.1.1

@@ -163,8 +169,8 @@
- -
+ +
@@ -175,7 +181,7 @@
- +
@@ -4136,341 +4142,2351 @@ promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } - if (!next) { - remainingElementsCount.value -= 1; - if (remainingElementsCount.value === 0) { - var resolveResult = promiseCapability['[[Resolve]]'].apply(undefined, values); + if (!next) { + remainingElementsCount.value -= 1; + if (remainingElementsCount.value === 0) { + var resolveResult = promiseCapability['[[Resolve]]'].apply(undefined, values); + + + } + return promiseCapability['[[Promise]]']; + } + try { + var nextValue = IteratorValue(next); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + try { + var nextPromise = c.resolve(nextValue); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + var resolveElement = PromiseAllResolveElementFunction(); + set_internal(resolveElement, '[[AlreadyCalled]]', { value: false }); + set_internal(resolveElement, '[[Index]]', index); + set_internal(resolveElement, '[[Values]]', values); + set_internal(resolveElement, '[[Capabilities]]', promiseCapability); + set_internal(resolveElement, '[[RemainingElements]]', remainingElementsCount); + remainingElementsCount.value += 1; + try { + var result = nextPromise.then(resolveElement, promiseCapability['[[Reject]]']); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + index += 1; + } + }); + + // 25.4.4.1.1 Promise.all Resolve Element Functions + + function PromiseAllResolveElementFunction() { + var F = function(x) { + var alreadyCalled = F['[[AlreadyCalled]]']; + if (alreadyCalled.value) return undefined; + alreadyCalled.value = true; + var index = F['[[Index]]']; + var values = F['[[Values]]']; + var promiseCapability = F['[[Capabilities]]']; + var remainingElementsCount = F['[[RemainingElements]]']; + try { + values[index] = x; + } catch (result) { + promiseCapability['[[Reject]]'].call(undefined, result); + return promiseCapability['[[Promise]]']; + } + remainingElementsCount.value -= 1; + if (remainingElementsCount.value === 0) + return promiseCapability['[[Resolve]]'].call(undefined, values); + return undefined; + }; + return F; + } + + // 25.4.4.2 Promise.prototype + + Promise.prototype = {}; + + // 25.4.4.3 Promise.race ( iterable ) + + define(Promise, 'race', function race(iterable) { + var c = strict(this); + var promiseCapability = NewPromiseCapability(c); + try { + var iterator = GetIterator(iterable); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + while (true) { + try { + var next = IteratorStep(iterator); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + if (!next) return promiseCapability['[[Promise]]']; + try { + var nextValue = IteratorValue(next); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + try { + var nextPromise = c.resolve(nextValue); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + try { + nextPromise.then(promiseCapability['[[Resolve]]'], promiseCapability['[[Reject]]']); + } catch (value) { + promiseCapability['[[Reject]]'].call(undefined, value); + return promiseCapability['[[Promise]]']; + } + } + }); + + // 25.4.4.4 Promise.reject ( r ) + + define(Promise, 'reject', function reject(r) { + var c = strict(this); + var promiseCapability = NewPromiseCapability(c); + var rejectResult = promiseCapability['[[Reject]]'].call(undefined, r); + return promiseCapability['[[Promise]]']; + }); + + // 25.4.4.5 Promise.resolve ( x ) + + define(Promise, 'resolve', function resolve(x) { + var c = strict(this); + if (IsPromise(x)) { + var constructor = x['[[PromiseConstructor]]']; + if (SameValue(constructor, c)) return x; + } + var promiseCapability = NewPromiseCapability(c); + var resolveResult = promiseCapability['[[Resolve]]'].call(undefined, x); + return promiseCapability['[[Promise]]']; + }); + + // 25.4.4.6 Promise [ @@create ] ( ) + // 25.4.4.6.1 AllocatePromise ( constructor ) + // 25.4.5 Properties of the Promise Prototype Object + // 25.4.5.1 Promise.prototype.catch ( onRejected ) + + define(Promise.prototype, 'catch', function catch_(onRejected) { + var promise = this; + return promise.then(undefined, onRejected); + }); + + // 25.4.5.2 Promise.prototype.constructor + + Promise.prototype.constructor = Promise; + + // 25.4.5.3 Promise.prototype.then ( onFulfilled , onRejected ) + + define(Promise.prototype, 'then', function then(onFulfilled, onRejected) { + var promise = this; + if (!IsPromise(promise)) throw TypeError(); + if (!IsCallable(onFulfilled)) onFulfilled = 'Identity'; + if (!IsCallable(onRejected)) onRejected = 'Thrower'; + var c = promise.constructor; + var promiseCapability = NewPromiseCapability(c); + var fulfillReaction = { '[[Capabilities]]': promiseCapability, + '[[Handler]]': onFulfilled }; + var rejectReaction = { '[[Capabilities]]': promiseCapability, + '[[Handler]]': onRejected }; + if (promise['[[PromiseState]]'] === 'pending') { + promise['[[PromiseFulfillReactions]]'].push(fulfillReaction); + promise['[[PromiseRejectReactions]]'].push(rejectReaction); + } else if (promise['[[PromiseState]]'] === 'fulfilled') { + var value = promise['[[PromiseResult]]']; + EnqueueJob('PromiseJobs', PromiseReactionJob, [fulfillReaction, value]); + } else if (promise['[[PromiseState]]'] === 'rejected') { + var reason = promise['[[PromiseResult]]']; + EnqueueJob('PromiseJobs', PromiseReactionJob, [rejectReaction, reason]); + } + return promiseCapability['[[Promise]]']; + }); + + // 25.4.6 Properties of Promise Instances + + if (!('Promise' in global) || OVERRIDE_NATIVE_FOR_TESTING) + global.Promise = Promise; + + // Patch early Promise.cast vs. Promise.resolve implementations + if ('cast' in global.Promise) global.Promise.resolve = global.Promise.cast; + }()); + + // 25.4.5.1 Promise.prototype [ @@toStringTag ] + define(Promise.prototype, $$toStringTag, 'Promise'); + + // --------------------------------------- + // 26 Reflection + // --------------------------------------- + + (function() { + // 26.1 The Reflect Object + if (!('Reflect' in global) || OVERRIDE_NATIVE_FOR_TESTING) + global.Reflect = {}; + + // 26.1.1 Reflect.apply ( target, thisArgument, argumentsList ) + define( + Reflect, 'apply', + function apply(target, thisArgument, argumentsList) { + if (!IsCallable(target)) throw TypeError(); + return Function.prototype.apply.call(target, thisArgument, argumentsList); + }); + + // 26.1.2 Reflect.construct ( target, argumentsList [, newTarget] ) + define( + Reflect, 'construct', + function construct(target, argumentsList) { + return __cons(target, argumentsList); + }); + + // 26.1.3 Reflect.defineProperty ( target, propertyKey, attributes ) + define( + Reflect, 'defineProperty', + function defineProperty(target, propertyKey, attributes) { + try { + Object.defineProperty(target, propertyKey, attributes); + return true; + } catch (_) { + return false; + } + }); + + // 26.1.4 Reflect.deleteProperty ( target, propertyKey ) + define( + Reflect, 'deleteProperty', + function deleteProperty(target,name) { + try { + delete target[name]; + return !HasOwnProperty(target, name); + } catch (_) { + return false; + } + }); + + // 26.1.5 Reflect.enumerate ( target ) + define( + Reflect, 'enumerate', + function enumerate(target) { + target = ToObject(target); + var iterator = Enumerate(target); + return iterator; + }); + + // 26.1.6 Reflect.get ( target, propertyKey [ , receiver ]) + define( + Reflect, 'get', + function get(target, name, receiver) { + target = ToObject(target); + name = String(name); + receiver = (receiver === undefined) ? target : ToObject(receiver); + var desc = getPropertyDescriptor(target, name); + if (desc && 'get' in desc) + return Function.prototype.call.call(desc['get'], receiver); + return target[name]; + }); + + // 26.1.7 Reflect.getOwnPropertyDescriptor ( target, propertyKey ) + define( + Reflect, 'getOwnPropertyDescriptor', + Object.getOwnPropertyDescriptor); + + // 26.1.8 Reflect.getPrototypeOf ( target ) + define( + Reflect, 'getPrototypeOf', + Object.getPrototypeOf); + + // 26.1.9 Reflect.has ( target, propertyKey ) + define( + Reflect, 'has', + function has(target,name) { + return String(name) in ToObject(target); + }); + + // 26.1.10 Reflect.isExtensible (target) + define( + Reflect, 'isExtensible', + Object.isExtensible); + + // 26.1.11 Reflect.ownKeys ( target ) + define( + Reflect, 'ownKeys', + function ownKeys(target) { + var obj = ToObject(target); + return Object.getOwnPropertyNames(obj); + }); + + // 26.1.12 Reflect.preventExtensions ( target ) + define( + Reflect, 'preventExtensions', + function preventExtensions(target) { + try { Object.preventExtensions(target); return true; } catch (_) { return false; } + }); + + // 26.1.13 Reflect.set ( target, propertyKey, V [ , receiver ] ) + define( + Reflect, 'set', + function set(target, name, value, receiver) { + target = ToObject(target); + name = String(name); + receiver = (receiver === undefined) ? target : ToObject(receiver); + var desc = getPropertyDescriptor(target, name); + try { + if (desc && 'set' in desc) + Function.prototype.call.call(desc['set'], receiver, value); + else + target[name] = value; + return true; + } catch (_) { + return false; + } + }); + + // 26.1.14 Reflect.setPrototypeOf ( target, proto ) + define( + Reflect, 'setPrototypeOf', + function setPrototypeOf(target, proto) { + try { + target.__proto__ = proto; + return Reflect.getPrototypeOf(target) === proto; + } catch(_) { + return false; + } + }); + + }()); + + // --------------------------------------- + // 26.2 Proxy Objects + // --------------------------------------- + + // Not polyfillable. + +}(self)); + +// This helper is defined outside the main scope so that the use of +// 'eval' does not taint the scope for minifiers. +function __cons(t, a) { + return eval('new t(' + a.map(function(_, i) { return 'a[' + i + ']'; }).join(',') + ')'); +} + + + +},{"safe-buffer":6}],6:[function(require,module,exports){ +module.exports = require('buffer') + +},{"buffer":2}]},{},[4])(4) +}); +