https://www.mainst.biz/scripts/src/engine/ie-search-support.js

1if (!Object.entries) {
2    Object.entries = function (obj) {
3        var ownProps = Object.keys(obj),
4            i = ownProps.length,
5            resArray = new Array(i); // preallocate the Array
6        while (i--)
7            resArray[i] = [ownProps[i], obj[ownProps[i]]];
8
9        return resArray;
10    };
11}
12
13
14(function (global, factory) {
15    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
16        typeof define === 'function' && define.amd ? define(factory) :
17            (global.ES6Promise = factory());
18}(this, (function () {
19    'use strict';
20
21    function objectOrFunction(x) {
22        var type = typeof x;
23        return x !== null && (type === 'object' || type === 'function');
24    }
25
26    function isFunction(x) {
27        return typeof x === 'function';
28    }
29
30
31    var _isArray = void 0;
32    if (Array.isArray) {
33        _isArray = Array.isArray;
34    } else {
35        _isArray = function (x) {
36            return Object.prototype.toString.call(x) === '[object Array]';
37        };
38    }
39
40    var isArray = _isArray;
41
42    var len = 0;
43    var vertxNext = void 0;
44    var customSchedulerFn = void 0;
45
46    var asap = function asap(callback, arg) {
47        queue[len] = callback;
48        queue[len + 1] = arg;
49        len += 2;
50        if (len === 2) {
51            // If len is 2, that means that we need to schedule an async flush.
52            // If additional callbacks are queued before the queue is flushed, they
53            // will be processed by this flush that we are scheduling.
54            if (customSchedulerFn) {
55                customSchedulerFn(flush);
56            } else {
57                scheduleFlush();
58            }
59        }
60    };
61
62    function setScheduler(scheduleFn) {
63        customSchedulerFn = scheduleFn;
64    }
65
66    function setAsap(asapFn) {
67        asap = asapFn;
68    }
69
70    var browserWindow = typeof window !== 'undefined' ? window : undefined;
71    var browserGlobal = browserWindow || {};
72    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
73    var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
74
75// test for web worker but not in IE10
76    var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
77
78// node
79    function useNextTick() {
80        // node version 0.10.x displays a deprecation warning when nextTick is used recursively
81        // see https://github.com/cujojs/when/issues/410 for details
82        return function () {
83            return process.nextTick(flush);
84        };
85    }
86
87// vertx
88    function useVertxTimer() {
89        if (typeof vertxNext !== 'undefined') {
90            return function () {
91                vertxNext(flush);
92            };
93        }
94
95        return useSetTimeout();
96    }
97
98    function useMutationObserver() {
99        var iterations = 0;
100        var observer = new BrowserMutationObserver(flush);
101        var node = document.createTextNode('');
102        observer.observe(node, {characterData: true});
103
104        return function () {
105            node.data = iterations = ++iterations % 2;
106        };
107    }
108
109// web worker
110    function useMessageChannel() {
111        var channel = new MessageChannel();
112        channel.port1.onmessage = flush;
113        return function () {
114            return channel.port2.postMessage(0);
115        };
116    }
117
118    function useSetTimeout() {
119        // Store setTimeout reference so es6-promise will be unaffected by
120        // other code modifying setTimeout (like sinon.useFakeTimers())
121        var globalSetTimeout = setTimeout;
122        return function () {
123            return globalSetTimeout(flush, 1);
124        };
125    }
126
127    var queue = new Array(1000);
128
129    function flush() {
130        for (var i = 0; i < len; i += 2) {
131            var callback = queue[i];
132            var arg = queue[i + 1];
133
134            callback(arg);
135
136            queue[i] = undefined;
137            queue[i + 1] = undefined;
138        }
139
140        len = 0;
141    }
142
143    function attemptVertx() {
144        try {
145            var vertx = Function('return this')().require('vertx');
146            vertxNext = vertx.runOnLoop || vertx.runOnContext;
147            return useVertxTimer();
148        } catch (e) {
149            return useSetTimeout();
150        }
151    }
152
153    var scheduleFlush = void 0;
154// Decide what async method to use to triggering processing of queued callbacks:
155    if (isNode) {
156        scheduleFlush = useNextTick();
157    } else if (BrowserMutationObserver) {
158        scheduleFlush = useMutationObserver();
159    } else if (isWorker) {

160        scheduleFlush = useMessageChannel();
161    } else if (browserWindow === undefined && typeof require === 'function') {
162        scheduleFlush = attemptVertx();
163    } else {
164        scheduleFlush = useSetTimeout();
165    }
166
167    function then(onFulfillment, onRejection) {
168        var parent = this;
169
170        var child = new this.constructor(noop);
171
172        if (child[PROMISE_ID] === undefined) {
173            makePromise(child);
174        }
175
176        var _state = parent._state;
177
178
179        if (_state) {
180            var callback = arguments[_state - 1];
181            asap(function () {
182                return invokeCallback(_state, child, callback, parent._result);
183            });
184        } else {
185            subscribe(parent, child, onFulfillment, onRejection);
186        }
187
188        return child;
189    }
190
191    /**
192     `Promise.resolve` returns a promise that will become resolved with the
193     passed `value`. It is shorthand for the following:
194
195     ```javascript
196     let promise = new Promise(function(resolve, reject){
197resolve(1);
198});
199
200     promise.then(function(value){
201// value === 1
202});
203     ```
204
205     Instead of writing the above, your code now simply becomes the following:
206
207     ```javascript
208     let promise = Promise.resolve(1);
209
210     promise.then(function(value){
211// value === 1
212});
213     ```
214
215     @method resolve
216     @static
217     @param {Any} value value that the returned promise will be resolved with
218     Useful for tooling.
219     @return {Promise} a promise that will become fulfilled with the given
220     `value`
221     */
222    function resolve$1(object) {
223        /*jshint validthis:true */
224        var Constructor = this;
225
226        if (object && typeof object === 'object' && object.constructor === Constructor) {
227            return object;
228        }
229
230        var promise = new Constructor(noop);
231        resolve(promise, object);
232        return promise;
233    }
234
235    var PROMISE_ID = Math.random().toString(36).substring(2);
236
237    function noop() {
238    }
239
240    var PENDING = void 0;
241    var FULFILLED = 1;
242    var REJECTED = 2;
243
244    function selfFulfillment() {
245        return new TypeError("You cannot resolve a promise with itself");
246    }
247
248    function cannotReturnOwn() {
249        return new TypeError('A promises callback cannot return that same promise.');
250    }
251
252    function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
253        try {
254            then$$1.call(value, fulfillmentHandler, rejectionHandler);
255        } catch (e) {
256            return e;
257        }
258    }
259
260    function handleForeignThenable(promise, thenable, then$$1) {
261        asap(function (promise) {
262            var sealed = false;
263            var error = tryThen(then$$1, thenable, function (value) {
264                if (sealed) {
265                    return;
266                }
267                sealed = true;
268                if (thenable !== value) {
269                    resolve(promise, value);
270                } else {
271                    fulfill(promise, value);
272                }
273            }, function (reason) {
274                if (sealed) {
275                    return;
276                }
277                sealed = true;
278
279                reject(promise, reason);
280            }, 'Settle: ' + (promise._label || ' unknown promise'));
281
282            if (!sealed && error) {
283                sealed = true;
284                reject(promise, error);
285            }
286        }, promise);
287    }
288
289    function handleOwnThenable(promise, thenable) {
290        if (thenable._state === FULFILLED) {
291            fulfill(promise, thenable._result);
292        } else if (thenable._state === REJECTED) {
293            reject(promise, thenable._result);
294        } else {
295            subscribe(thenable, undefined, function (value) {
296                return resolve(promise, value);
297            }, function (reason) {
298                return reject(promise, reason);
299            });
300        }
301    }
302
303    function handleMaybeThenable(promise, maybeThenable, then$$1) {
304        if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
305            handleOwnThenable(promise, maybeThenable);
306        } else {
307            if (then$$1 === undefined) {
308                fulfill(promise, maybeThenable);
309            } else if (isFunction(then$$1)) {
310                handleForeignThenable(promise, maybeThenable, then$$1);
311            } else {
312                fulfill(promise, maybeThenable);
313            }
314        }
315    }
316
317    function resolve(promise, value) {
318        if (promise === value) {
319            reject(promise, selfFulfillment());
320        } else if (objectOrFunction(value)) {
321            var then$$1 = void 0;
322            try {
323                then$$1 = value.then;
324            } catch (error) {
325                reject(promise, error);
326                return;
327            }
328            handleMaybeThenable(promise, value, then$$1);
329        } else {
330            fulfill(promise, value);
331        }
332    }
333
334    function publishRejection(promise) {
335        if (promise._onerror) {

336            promise._onerror(promise._result);
337        }
338
339        publish(promise);
340    }
341
342    function fulfill(promise, value) {
343        if (promise._state !== PENDING) {
344            return;
345        }
346
347        promise._result = value;
348        promise._state = FULFILLED;
349
350        if (promise._subscribers.length !== 0) {
351            asap(publish, promise);
352        }
353    }
354
355    function reject(promise, reason) {
356        if (promise._state !== PENDING) {
357            return;
358        }
359        promise._state = REJECTED;
360        promise._result = reason;
361
362        asap(publishRejection, promise);
363    }
364
365    function subscribe(parent, child, onFulfillment, onRejection) {
366        var _subscribers = parent._subscribers;
367        var length = _subscribers.length;
368
369
370        parent._onerror = null;
371
372        _subscribers[length] = child;
373        _subscribers[length + FULFILLED] = onFulfillment;
374        _subscribers[length + REJECTED] = onRejection;
375
376        if (length === 0 && parent._state) {
377            asap(publish, parent);
378        }
379    }
380
381    function publish(promise) {
382        var subscribers = promise._subscribers;
383        var settled = promise._state;
384
385        if (subscribers.length === 0) {
386            return;
387        }
388
389        var child = void 0,
390            callback = void 0,
391            detail = promise._result;
392
393        for (var i = 0; i < subscribers.length; i += 3) {
394            child = subscribers[i];
395            callback = subscribers[i + settled];
396
397            if (child) {
398                invokeCallback(settled, child, callback, detail);
399            } else {
400                callback(detail);
401            }
402        }
403
404        promise._subscribers.length = 0;
405    }
406
407    function invokeCallback(settled, promise, callback, detail) {
408        var hasCallback = isFunction(callback),
409            value = void 0,
410            error = void 0,
411            succeeded = true;
412
413        if (hasCallback) {
414            try {
415                value = callback(detail);
416            } catch (e) {
417                succeeded = false;
418                error = e;
419            }
420
421            if (promise === value) {
422                reject(promise, cannotReturnOwn());
423                return;
424            }
425        } else {
426            value = detail;
427        }
428
429        if (promise._state !== PENDING) {
430            // noop
431        } else if (hasCallback && succeeded) {
432            resolve(promise, value);
433        } else if (succeeded === false) {
434            reject(promise, error);
435        } else if (settled === FULFILLED) {
436            fulfill(promise, value);
437        } else if (settled === REJECTED) {
438            reject(promise, value);
439        }
440    }
441
442    function initializePromise(promise, resolver) {
443        try {
444            resolver(function resolvePromise(value) {
445                resolve(promise, value);
446            }, function rejectPromise(reason) {
447                reject(promise, reason);
448            });
449        } catch (e) {
450            reject(promise, e);
451        }
452    }
453
454    var id = 0;
455
456    function nextId() {
457        return id++;
458    }
459
460    function makePromise(promise) {
461        promise[PROMISE_ID] = id++;
462        promise._state = undefined;
463        promise._result = undefined;
464        promise._subscribers = [];
465    }
466
467    function validationError() {
468        return new Error('Array Methods must be provided an Array');
469    }
470
471    var Enumerator = function () {
472        function Enumerator(Constructor, input) {
473            this._instanceConstructor = Constructor;
474            this.promise = new Constructor(noop);
475
476            if (!this.promise[PROMISE_ID]) {
477                makePromise(this.promise);
478            }
479
480            if (isArray(input)) {
481                this.length = input.length;
482                this._remaining = input.length;
483
484                this._result = new Array(this.length);
485
486                if (this.length === 0) {
487                    fulfill(this.promise, this._result);
488                } else {
489                    this.length = this.length || 0;
490                    this._enumerate(input);
491                    if (this._remaining === 0) {
492                        fulfill(this.promise, this._result);
493                    }
494                }
495            } else {
496                reject(this.promise, validationError());
497            }
498        }
499
500        Enumerator.prototype._enumerate = function _enumerate(input) {
501            for (var i = 0; this._state === PENDING && i < input.length; i++) {
502                this._eachEntry(input[i], i);
503            }
504        };
505
506        Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
507            var c = this._instanceConstructor;
508            var resolve$$1 = c.resolve;
509
510
511            if (resolve$$1 === resolve$1) {
512                var _then = void 0;
513                var error = void 0;
514                var didError = false;
515                try {
516                    _then = entry.then;
517                } catch (e) {
518                    didError = true;
519                    error = e;
520                }
521
522                if (_then === then && entry._state !== PENDING) {
523                    this._settledAt(entry._state, i, entry._result);
524                } else if (typeof _then !== 'function') {
525                    this._remaining--;
526                    this._result[i] = entry;
527                } else if (c === Promise$2) {
528                    var promise = new c(noop);
529                    if (didError) {
530                        reject(promise, error);
531                    } else {
532                        handleMaybeThenable(promise, entry, _then);
533                    }
534                    this._willSettleAt(promise, i);
535                } else {
536                    this._willSettleAt(new c(function (resolve$$1) {
537                        return resolve$$1(entry);
538                    }), i);
539                }
540            } else {
541                this._willSettleAt(resolve$$1(entry), i);
542            }
543        };
544
545        Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
546            var promise = this.promise;
547
548
549            if (promise._state === PENDING) {
550                this._remaining--;
551
552                if (state === REJECTED) {
553                    reject(promise, value);
554                } else {
555                    this._result[i] = value;
556                }
557            }
558
559            if (this._remaining === 0) {
560                fulfill(promise, this._result);
561            }
562        };
563
564        Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
565            var enumerator = this;
566
567            subscribe(promise, undefined, function (value) {
568                return enumerator._settledAt(FULFILLED, i, value);
569            }, function (reason) {
570                return enumerator._settledAt(REJECTED, i, reason);
571            });
572        };
573
574        return Enumerator;
575    }();
576
577    /**
578     `Promise.all` accepts an array of promises, and returns a new promise which
579     is fulfilled with an array of fulfillment values for the passed promises, or
580     rejected with the reason of the first passed promise to be rejected. It casts all
581     elements of the passed iterable to promises as it runs this algorithm.
582
583     Example:
584
585     ```javascript
586     let promise1 = resolve(1);
587     let promise2 = resolve(2);
588     let promise3 = resolve(3);
589     let promises = [ promise1, promise2, promise3 ];
590
591     Promise.all(promises).then(function(array){
592// The array here would be [ 1, 2, 3 ];
593});
594     ```
595
596     If any of the `promises` given to `all` are rejected, the first promise
597     that is rejected will be given as an argument to the returned promises's
598     rejection handler. For example:
599
600     Example:
601
602     ```javascript
603     let promise1 = resolve(1);
604     let promise2 = reject(new Error("2"));
605     let promise3 = reject(new Error("3"));
606     let promises = [ promise1, promise2, promise3 ];
607
608     Promise.all(promises).then(function(array){
609// Code here never runs because there are rejected promises!
610}, function(error) {
611// error.message === "2"
612});
613     ```
614
615     @method all
616     @static
617     @param {Array} entries array of promises
618     @param {String} label optional string for labeling the promise.
619     Useful for tooling.
620     @return {Promise} promise that is fulfilled when all `promises` have been
621     fulfilled, or rejected if any of them become rejected.
622     @static
623     */
624    function all(entries) {
625        return new Enumerator(this, entries).promise;
626    }
627
628    /**
629     `Promise.race` returns a new promise which is settled in the same way as the
630     first passed promise to settle.
631
632     Example:
633
634     ```javascript
635     let promise1 = new Promise(function(resolve, reject){
636setTimeout(function(){
637  resolve('promise 1');
638}, 200);
639});
640
641     let promise2 = new Promise(function(resolve, reject){
642setTimeout(function(){
643  resolve('promise 2');
644}, 100);
645});
646
647     Promise.race([promise1, promise2]).then(function(result){
648// result === 'promise 2' because it was resolved before promise1
649// was resolved.
650});
651     ```
652
653     `Promise.race` is deterministic in that only the state of the first
654     settled promise matters. For example, even if other promises given to the
655     `promises` array argument are resolved, but the first settled promise has
656     become rejected before the other promises became fulfilled, the returned
657     promise will become rejected:
658
659     ```javascript
660     let promise1 = new Promise(function(resolve, reject){
661setTimeout(function(){
662  resolve('promise 1');
663}, 200);
664});
665
666     let promise2 = new Promise(function(resolve, reject){
667setTimeout(function(){
668  reject(new Error('promise 2'));
669}, 100);
670});
671
672     Promise.race([promise1, promise2]).then(function(result){
673// Code here never runs
674}, function(reason){