| /** |
| Some credit for this helper goes to http://github.com/YuzuJS/setImmediate |
| */ |
| /** PURE_IMPORTS_START ._root PURE_IMPORTS_END */ |
| import { root } from './root'; |
| export var ImmediateDefinition = /*@__PURE__*/ (/*@__PURE__*/ function () { |
| function ImmediateDefinition(root) { |
| this.root = root; |
| if (root.setImmediate && typeof root.setImmediate === 'function') { |
| this.setImmediate = root.setImmediate.bind(root); |
| this.clearImmediate = root.clearImmediate.bind(root); |
| } |
| else { |
| this.nextHandle = 1; |
| this.tasksByHandle = {}; |
| this.currentlyRunningATask = false; |
| // Don't get fooled by e.g. browserify environments. |
| if (this.canUseProcessNextTick()) { |
| // For Node.js before 0.9 |
| this.setImmediate = this.createProcessNextTickSetImmediate(); |
| } |
| else if (this.canUsePostMessage()) { |
| // For non-IE10 modern browsers |
| this.setImmediate = this.createPostMessageSetImmediate(); |
| } |
| else if (this.canUseMessageChannel()) { |
| // For web workers, where supported |
| this.setImmediate = this.createMessageChannelSetImmediate(); |
| } |
| else if (this.canUseReadyStateChange()) { |
| // For IE 6–8 |
| this.setImmediate = this.createReadyStateChangeSetImmediate(); |
| } |
| else { |
| // For older browsers |
| this.setImmediate = this.createSetTimeoutSetImmediate(); |
| } |
| var ci = function clearImmediate(handle) { |
| delete clearImmediate.instance.tasksByHandle[handle]; |
| }; |
| ci.instance = this; |
| this.clearImmediate = ci; |
| } |
| } |
| ImmediateDefinition.prototype.identify = function (o) { |
| return this.root.Object.prototype.toString.call(o); |
| }; |
| ImmediateDefinition.prototype.canUseProcessNextTick = function () { |
| return this.identify(this.root.process) === '[object process]'; |
| }; |
| ImmediateDefinition.prototype.canUseMessageChannel = function () { |
| return Boolean(this.root.MessageChannel); |
| }; |
| ImmediateDefinition.prototype.canUseReadyStateChange = function () { |
| var document = this.root.document; |
| return Boolean(document && 'onreadystatechange' in document.createElement('script')); |
| }; |
| ImmediateDefinition.prototype.canUsePostMessage = function () { |
| var root = this.root; |
| // The test against `importScripts` prevents this implementation from being installed inside a web worker, |
| // where `root.postMessage` means something completely different and can't be used for this purpose. |
| if (root.postMessage && !root.importScripts) { |
| var postMessageIsAsynchronous_1 = true; |
| var oldOnMessage = root.onmessage; |
| root.onmessage = function () { |
| postMessageIsAsynchronous_1 = false; |
| }; |
| root.postMessage('', '*'); |
| root.onmessage = oldOnMessage; |
| return postMessageIsAsynchronous_1; |
| } |
| return false; |
| }; |
| // This function accepts the same arguments as setImmediate, but |
| // returns a function that requires no arguments. |
| ImmediateDefinition.prototype.partiallyApplied = function (handler) { |
| var args = []; |
| for (var _i = 1; _i < arguments.length; _i++) { |
| args[_i - 1] = arguments[_i]; |
| } |
| var fn = function result() { |
| var _a = result, handler = _a.handler, args = _a.args; |
| if (typeof handler === 'function') { |
| handler.apply(undefined, args); |
| } |
| else { |
| (new Function('' + handler))(); |
| } |
| }; |
| fn.handler = handler; |
| fn.args = args; |
| return fn; |
| }; |
| ImmediateDefinition.prototype.addFromSetImmediateArguments = function (args) { |
| this.tasksByHandle[this.nextHandle] = this.partiallyApplied.apply(undefined, args); |
| return this.nextHandle++; |
| }; |
| ImmediateDefinition.prototype.createProcessNextTickSetImmediate = function () { |
| var fn = function setImmediate() { |
| var instance = setImmediate.instance; |
| var handle = instance.addFromSetImmediateArguments(arguments); |
| instance.root.process.nextTick(instance.partiallyApplied(instance.runIfPresent, handle)); |
| return handle; |
| }; |
| fn.instance = this; |
| return fn; |
| }; |
| ImmediateDefinition.prototype.createPostMessageSetImmediate = function () { |
| // Installs an event handler on `global` for the `message` event: see |
| // * https://developer.mozilla.org/en/DOM/window.postMessage |
| // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages |
| var root = this.root; |
| var messagePrefix = 'setImmediate$' + root.Math.random() + '$'; |
| var onGlobalMessage = function globalMessageHandler(event) { |
| var instance = globalMessageHandler.instance; |
| if (event.source === root && |
| typeof event.data === 'string' && |
| event.data.indexOf(messagePrefix) === 0) { |
| instance.runIfPresent(+event.data.slice(messagePrefix.length)); |
| } |
| }; |
| onGlobalMessage.instance = this; |
| root.addEventListener('message', onGlobalMessage, false); |
| var fn = function setImmediate() { |
| var _a = setImmediate, messagePrefix = _a.messagePrefix, instance = _a.instance; |
| var handle = instance.addFromSetImmediateArguments(arguments); |
| instance.root.postMessage(messagePrefix + handle, '*'); |
| return handle; |
| }; |
| fn.instance = this; |
| fn.messagePrefix = messagePrefix; |
| return fn; |
| }; |
| ImmediateDefinition.prototype.runIfPresent = function (handle) { |
| // From the spec: 'Wait until any invocations of this algorithm started before this one have completed.' |
| // So if we're currently running a task, we'll need to delay this invocation. |
| if (this.currentlyRunningATask) { |
| // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a |
| // 'too much recursion' error. |
| this.root.setTimeout(this.partiallyApplied(this.runIfPresent, handle), 0); |
| } |
| else { |
| var task = this.tasksByHandle[handle]; |
| if (task) { |
| this.currentlyRunningATask = true; |
| try { |
| task(); |
| } |
| finally { |
| this.clearImmediate(handle); |
| this.currentlyRunningATask = false; |
| } |
| } |
| } |
| }; |
| ImmediateDefinition.prototype.createMessageChannelSetImmediate = function () { |
| var _this = this; |
| var channel = new this.root.MessageChannel(); |
| channel.port1.onmessage = function (event) { |
| var handle = event.data; |
| _this.runIfPresent(handle); |
| }; |
| var fn = function setImmediate() { |
| var _a = setImmediate, channel = _a.channel, instance = _a.instance; |
| var handle = instance.addFromSetImmediateArguments(arguments); |
| channel.port2.postMessage(handle); |
| return handle; |
| }; |
| fn.channel = channel; |
| fn.instance = this; |
| return fn; |
| }; |
| ImmediateDefinition.prototype.createReadyStateChangeSetImmediate = function () { |
| var fn = function setImmediate() { |
| var instance = setImmediate.instance; |
| var root = instance.root; |
| var doc = root.document; |
| var html = doc.documentElement; |
| var handle = instance.addFromSetImmediateArguments(arguments); |
| // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted |
| // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called. |
| var script = doc.createElement('script'); |
| script.onreadystatechange = function () { |
| instance.runIfPresent(handle); |
| script.onreadystatechange = null; |
| html.removeChild(script); |
| script = null; |
| }; |
| html.appendChild(script); |
| return handle; |
| }; |
| fn.instance = this; |
| return fn; |
| }; |
| ImmediateDefinition.prototype.createSetTimeoutSetImmediate = function () { |
| var fn = function setImmediate() { |
| var instance = setImmediate.instance; |
| var handle = instance.addFromSetImmediateArguments(arguments); |
| instance.root.setTimeout(instance.partiallyApplied(instance.runIfPresent, handle), 0); |
| return handle; |
| }; |
| fn.instance = this; |
| return fn; |
| }; |
| return ImmediateDefinition; |
| }()); |
| export var Immediate = /*@__PURE__*/ new ImmediateDefinition(root); |
| //# sourceMappingURL=Immediate.js.map |