Merge pull request #3268 from tomhughes/capitalisation

[rails.git] / vendor / assets / iD / iD / mapillary-js / mapillary.unminified.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.mapillary = {}));
}(this, (function (exports) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function isFunction(x) {
        return typeof x === 'function';
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var _enable_super_gross_mode_that_will_cause_bad_things = false;
    var config = {
        Promise: undefined,
        set useDeprecatedSynchronousErrorHandling(value) {
            if (value) {
                var error = /*@__PURE__*/ new Error();
                /*@__PURE__*/ console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' + error.stack);
            }
            _enable_super_gross_mode_that_will_cause_bad_things = value;
        },
        get useDeprecatedSynchronousErrorHandling() {
            return _enable_super_gross_mode_that_will_cause_bad_things;
        },
    };

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function hostReportError(err) {
        setTimeout(function () { throw err; }, 0);
    }

    /** PURE_IMPORTS_START _config,_util_hostReportError PURE_IMPORTS_END */
    var empty$1 = {
        closed: true,
        next: function (value) { },
        error: function (err) {
            if (config.useDeprecatedSynchronousErrorHandling) {
                throw err;
            }
            else {
                hostReportError(err);
            }
        },
        complete: function () { }
    };

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var isArray$1 = /*@__PURE__*/ (function () { return Array.isArray || (function (x) { return x && typeof x.length === 'number'; }); })();

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function isObject$1(x) {
        return x !== null && typeof x === 'object';
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var UnsubscriptionErrorImpl = /*@__PURE__*/ (function () {
        function UnsubscriptionErrorImpl(errors) {
            Error.call(this);
            this.message = errors ?
                errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ') : '';
            this.name = 'UnsubscriptionError';
            this.errors = errors;
            return this;
        }
        UnsubscriptionErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);
        return UnsubscriptionErrorImpl;
    })();
    var UnsubscriptionError = UnsubscriptionErrorImpl;

    /** PURE_IMPORTS_START _util_isArray,_util_isObject,_util_isFunction,_util_UnsubscriptionError PURE_IMPORTS_END */
    var Subscription = /*@__PURE__*/ (function () {
        function Subscription(unsubscribe) {
            this.closed = false;
            this._parentOrParents = null;
            this._subscriptions = null;
            if (unsubscribe) {
                this._ctorUnsubscribe = true;
                this._unsubscribe = unsubscribe;
            }
        }
        Subscription.prototype.unsubscribe = function () {
            var errors;
            if (this.closed) {
                return;
            }
            var _a = this, _parentOrParents = _a._parentOrParents, _ctorUnsubscribe = _a._ctorUnsubscribe, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
            this.closed = true;
            this._parentOrParents = null;
            this._subscriptions = null;
            if (_parentOrParents instanceof Subscription) {
                _parentOrParents.remove(this);
            }
            else if (_parentOrParents !== null) {
                for (var index = 0; index < _parentOrParents.length; ++index) {
                    var parent_1 = _parentOrParents[index];
                    parent_1.remove(this);
                }
            }
            if (isFunction(_unsubscribe)) {
                if (_ctorUnsubscribe) {
                    this._unsubscribe = undefined;
                }
                try {
                    _unsubscribe.call(this);
                }
                catch (e) {
                    errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
                }
            }
            if (isArray$1(_subscriptions)) {
                var index = -1;
                var len = _subscriptions.length;
                while (++index < len) {
                    var sub = _subscriptions[index];
                    if (isObject$1(sub)) {
                        try {
                            sub.unsubscribe();
                        }
                        catch (e) {
                            errors = errors || [];
                            if (e instanceof UnsubscriptionError) {
                                errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
                            }
                            else {
                                errors.push(e);
                            }
                        }
                    }
                }
            }
            if (errors) {
                throw new UnsubscriptionError(errors);
            }
        };
        Subscription.prototype.add = function (teardown) {
            var subscription = teardown;
            if (!teardown) {
                return Subscription.EMPTY;
            }
            switch (typeof teardown) {
                case 'function':
                    subscription = new Subscription(teardown);
                case 'object':
                    if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {
                        return subscription;
                    }
                    else if (this.closed) {
                        subscription.unsubscribe();
                        return subscription;
                    }
                    else if (!(subscription instanceof Subscription)) {
                        var tmp = subscription;
                        subscription = new Subscription();
                        subscription._subscriptions = [tmp];
                    }
                    break;
                default: {
                    throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
                }
            }
            var _parentOrParents = subscription._parentOrParents;
            if (_parentOrParents === null) {
                subscription._parentOrParents = this;
            }
            else if (_parentOrParents instanceof Subscription) {
                if (_parentOrParents === this) {
                    return subscription;
                }
                subscription._parentOrParents = [_parentOrParents, this];
            }
            else if (_parentOrParents.indexOf(this) === -1) {
                _parentOrParents.push(this);
            }
            else {
                return subscription;
            }
            var subscriptions = this._subscriptions;
            if (subscriptions === null) {
                this._subscriptions = [subscription];
            }
            else {
                subscriptions.push(subscription);
            }
            return subscription;
        };
        Subscription.prototype.remove = function (subscription) {
            var subscriptions = this._subscriptions;
            if (subscriptions) {
                var subscriptionIndex = subscriptions.indexOf(subscription);
                if (subscriptionIndex !== -1) {
                    subscriptions.splice(subscriptionIndex, 1);
                }
            }
        };
        Subscription.EMPTY = (function (empty) {
            empty.closed = true;
            return empty;
        }(new Subscription()));
        return Subscription;
    }());
    function flattenUnsubscriptionErrors(errors) {
        return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError) ? err.errors : err); }, []);
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var rxSubscriber = /*@__PURE__*/ (function () {
        return typeof Symbol === 'function'
            ? /*@__PURE__*/ Symbol('rxSubscriber')
            : '@@rxSubscriber_' + /*@__PURE__*/ Math.random();
    })();

    /** PURE_IMPORTS_START tslib,_util_isFunction,_Observer,_Subscription,_internal_symbol_rxSubscriber,_config,_util_hostReportError PURE_IMPORTS_END */
    var Subscriber = /*@__PURE__*/ (function (_super) {
        __extends(Subscriber, _super);
        function Subscriber(destinationOrNext, error, complete) {
            var _this = _super.call(this) || this;
            _this.syncErrorValue = null;
            _this.syncErrorThrown = false;
            _this.syncErrorThrowable = false;
            _this.isStopped = false;
            switch (arguments.length) {
                case 0:
                    _this.destination = empty$1;
                    break;
                case 1:
                    if (!destinationOrNext) {
                        _this.destination = empty$1;
                        break;
                    }
                    if (typeof destinationOrNext === 'object') {
                        if (destinationOrNext instanceof Subscriber) {
                            _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
                            _this.destination = destinationOrNext;
                            destinationOrNext.add(_this);
                        }
                        else {
                            _this.syncErrorThrowable = true;
                            _this.destination = new SafeSubscriber(_this, destinationOrNext);
                        }
                        break;
                    }
                default:
                    _this.syncErrorThrowable = true;
                    _this.destination = new SafeSubscriber(_this, destinationOrNext, error, complete);
                    break;
            }
            return _this;
        }
        Subscriber.prototype[rxSubscriber] = function () { return this; };
        Subscriber.create = function (next, error, complete) {
            var subscriber = new Subscriber(next, error, complete);
            subscriber.syncErrorThrowable = false;
            return subscriber;
        };
        Subscriber.prototype.next = function (value) {
            if (!this.isStopped) {
                this._next(value);
            }
        };
        Subscriber.prototype.error = function (err) {
            if (!this.isStopped) {
                this.isStopped = true;
                this._error(err);
            }
        };
        Subscriber.prototype.complete = function () {
            if (!this.isStopped) {
                this.isStopped = true;
                this._complete();
            }
        };
        Subscriber.prototype.unsubscribe = function () {
            if (this.closed) {
                return;
            }
            this.isStopped = true;
            _super.prototype.unsubscribe.call(this);
        };
        Subscriber.prototype._next = function (value) {
            this.destination.next(value);
        };
        Subscriber.prototype._error = function (err) {
            this.destination.error(err);
            this.unsubscribe();
        };
        Subscriber.prototype._complete = function () {
            this.destination.complete();
            this.unsubscribe();
        };
        Subscriber.prototype._unsubscribeAndRecycle = function () {
            var _parentOrParents = this._parentOrParents;
            this._parentOrParents = null;
            this.unsubscribe();
            this.closed = false;
            this.isStopped = false;
            this._parentOrParents = _parentOrParents;
            return this;
        };
        return Subscriber;
    }(Subscription));
    var SafeSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SafeSubscriber, _super);
        function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {
            var _this = _super.call(this) || this;
            _this._parentSubscriber = _parentSubscriber;
            var next;
            var context = _this;
            if (isFunction(observerOrNext)) {
                next = observerOrNext;
            }
            else if (observerOrNext) {
                next = observerOrNext.next;
                error = observerOrNext.error;
                complete = observerOrNext.complete;
                if (observerOrNext !== empty$1) {
                    context = Object.create(observerOrNext);
                    if (isFunction(context.unsubscribe)) {
                        _this.add(context.unsubscribe.bind(context));
                    }
                    context.unsubscribe = _this.unsubscribe.bind(_this);
                }
            }
            _this._context = context;
            _this._next = next;
            _this._error = error;
            _this._complete = complete;
            return _this;
        }
        SafeSubscriber.prototype.next = function (value) {
            if (!this.isStopped && this._next) {
                var _parentSubscriber = this._parentSubscriber;
                if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
                    this.__tryOrUnsub(this._next, value);
                }
                else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
                    this.unsubscribe();
                }
            }
        };
        SafeSubscriber.prototype.error = function (err) {
            if (!this.isStopped) {
                var _parentSubscriber = this._parentSubscriber;
                var useDeprecatedSynchronousErrorHandling = config.useDeprecatedSynchronousErrorHandling;
                if (this._error) {
                    if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
                        this.__tryOrUnsub(this._error, err);
                        this.unsubscribe();
                    }
                    else {
                        this.__tryOrSetError(_parentSubscriber, this._error, err);
                        this.unsubscribe();
                    }
                }
                else if (!_parentSubscriber.syncErrorThrowable) {
                    this.unsubscribe();
                    if (useDeprecatedSynchronousErrorHandling) {
                        throw err;
                    }
                    hostReportError(err);
                }
                else {
                    if (useDeprecatedSynchronousErrorHandling) {
                        _parentSubscriber.syncErrorValue = err;
                        _parentSubscriber.syncErrorThrown = true;
                    }
                    else {
                        hostReportError(err);
                    }
                    this.unsubscribe();
                }
            }
        };
        SafeSubscriber.prototype.complete = function () {
            var _this = this;
            if (!this.isStopped) {
                var _parentSubscriber = this._parentSubscriber;
                if (this._complete) {
                    var wrappedComplete = function () { return _this._complete.call(_this._context); };
                    if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
                        this.__tryOrUnsub(wrappedComplete);
                        this.unsubscribe();
                    }
                    else {
                        this.__tryOrSetError(_parentSubscriber, wrappedComplete);
                        this.unsubscribe();
                    }
                }
                else {
                    this.unsubscribe();
                }
            }
        };
        SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {
            try {
                fn.call(this._context, value);
            }
            catch (err) {
                this.unsubscribe();
                if (config.useDeprecatedSynchronousErrorHandling) {
                    throw err;
                }
                else {
                    hostReportError(err);
                }
            }
        };
        SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {
            if (!config.useDeprecatedSynchronousErrorHandling) {
                throw new Error('bad call');
            }
            try {
                fn.call(this._context, value);
            }
            catch (err) {
                if (config.useDeprecatedSynchronousErrorHandling) {
                    parent.syncErrorValue = err;
                    parent.syncErrorThrown = true;
                    return true;
                }
                else {
                    hostReportError(err);
                    return true;
                }
            }
            return false;
        };
        SafeSubscriber.prototype._unsubscribe = function () {
            var _parentSubscriber = this._parentSubscriber;
            this._context = null;
            this._parentSubscriber = null;
            _parentSubscriber.unsubscribe();
        };
        return SafeSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _Subscriber PURE_IMPORTS_END */
    function canReportError(observer) {
        while (observer) {
            var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped;
            if (closed_1 || isStopped) {
                return false;
            }
            else if (destination && destination instanceof Subscriber) {
                observer = destination;
            }
            else {
                observer = null;
            }
        }
        return true;
    }

    /** PURE_IMPORTS_START _Subscriber,_symbol_rxSubscriber,_Observer PURE_IMPORTS_END */
    function toSubscriber(nextOrObserver, error, complete) {
        if (nextOrObserver) {
            if (nextOrObserver instanceof Subscriber) {
                return nextOrObserver;
            }
            if (nextOrObserver[rxSubscriber]) {
                return nextOrObserver[rxSubscriber]();
            }
        }
        if (!nextOrObserver && !error && !complete) {
            return new Subscriber(empty$1);
        }
        return new Subscriber(nextOrObserver, error, complete);
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var observable = /*@__PURE__*/ (function () { return typeof Symbol === 'function' && Symbol.observable || '@@observable'; })();

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function identity(x) {
        return x;
    }

    /** PURE_IMPORTS_START _identity PURE_IMPORTS_END */
    function pipe() {
        var fns = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            fns[_i] = arguments[_i];
        }
        return pipeFromArray(fns);
    }
    function pipeFromArray(fns) {
        if (fns.length === 0) {
            return identity;
        }
        if (fns.length === 1) {
            return fns[0];
        }
        return function piped(input) {
            return fns.reduce(function (prev, fn) { return fn(prev); }, input);
        };
    }

    /** PURE_IMPORTS_START _util_canReportError,_util_toSubscriber,_symbol_observable,_util_pipe,_config PURE_IMPORTS_END */
    var Observable = /*@__PURE__*/ (function () {
        function Observable(subscribe) {
            this._isScalar = false;
            if (subscribe) {
                this._subscribe = subscribe;
            }
        }
        Observable.prototype.lift = function (operator) {
            var observable = new Observable();
            observable.source = this;
            observable.operator = operator;
            return observable;
        };
        Observable.prototype.subscribe = function (observerOrNext, error, complete) {
            var operator = this.operator;
            var sink = toSubscriber(observerOrNext, error, complete);
            if (operator) {
                sink.add(operator.call(sink, this.source));
            }
            else {
                sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?
                    this._subscribe(sink) :
                    this._trySubscribe(sink));
            }
            if (config.useDeprecatedSynchronousErrorHandling) {
                if (sink.syncErrorThrowable) {
                    sink.syncErrorThrowable = false;
                    if (sink.syncErrorThrown) {
                        throw sink.syncErrorValue;
                    }
                }
            }
            return sink;
        };
        Observable.prototype._trySubscribe = function (sink) {
            try {
                return this._subscribe(sink);
            }
            catch (err) {
                if (config.useDeprecatedSynchronousErrorHandling) {
                    sink.syncErrorThrown = true;
                    sink.syncErrorValue = err;
                }
                if (canReportError(sink)) {
                    sink.error(err);
                }
                else {
                    console.warn(err);
                }
            }
        };
        Observable.prototype.forEach = function (next, promiseCtor) {
            var _this = this;
            promiseCtor = getPromiseCtor(promiseCtor);
            return new promiseCtor(function (resolve, reject) {
                var subscription;
                subscription = _this.subscribe(function (value) {
                    try {
                        next(value);
                    }
                    catch (err) {
                        reject(err);
                        if (subscription) {
                            subscription.unsubscribe();
                        }
                    }
                }, reject, resolve);
            });
        };
        Observable.prototype._subscribe = function (subscriber) {
            var source = this.source;
            return source && source.subscribe(subscriber);
        };
        Observable.prototype[observable] = function () {
            return this;
        };
        Observable.prototype.pipe = function () {
            var operations = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                operations[_i] = arguments[_i];
            }
            if (operations.length === 0) {
                return this;
            }
            return pipeFromArray(operations)(this);
        };
        Observable.prototype.toPromise = function (promiseCtor) {
            var _this = this;
            promiseCtor = getPromiseCtor(promiseCtor);
            return new promiseCtor(function (resolve, reject) {
                var value;
                _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });
            });
        };
        Observable.create = function (subscribe) {
            return new Observable(subscribe);
        };
        return Observable;
    }());
    function getPromiseCtor(promiseCtor) {
        if (!promiseCtor) {
            promiseCtor = Promise;
        }
        if (!promiseCtor) {
            throw new Error('no Promise impl found');
        }
        return promiseCtor;
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var ObjectUnsubscribedErrorImpl = /*@__PURE__*/ (function () {
        function ObjectUnsubscribedErrorImpl() {
            Error.call(this);
            this.message = 'object unsubscribed';
            this.name = 'ObjectUnsubscribedError';
            return this;
        }
        ObjectUnsubscribedErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);
        return ObjectUnsubscribedErrorImpl;
    })();
    var ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;

    /** PURE_IMPORTS_START tslib,_Subscription PURE_IMPORTS_END */
    var SubjectSubscription = /*@__PURE__*/ (function (_super) {
        __extends(SubjectSubscription, _super);
        function SubjectSubscription(subject, subscriber) {
            var _this = _super.call(this) || this;
            _this.subject = subject;
            _this.subscriber = subscriber;
            _this.closed = false;
            return _this;
        }
        SubjectSubscription.prototype.unsubscribe = function () {
            if (this.closed) {
                return;
            }
            this.closed = true;
            var subject = this.subject;
            var observers = subject.observers;
            this.subject = null;
            if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {
                return;
            }
            var subscriberIndex = observers.indexOf(this.subscriber);
            if (subscriberIndex !== -1) {
                observers.splice(subscriberIndex, 1);
            }
        };
        return SubjectSubscription;
    }(Subscription));

    /** PURE_IMPORTS_START tslib,_Observable,_Subscriber,_Subscription,_util_ObjectUnsubscribedError,_SubjectSubscription,_internal_symbol_rxSubscriber PURE_IMPORTS_END */
    var SubjectSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SubjectSubscriber, _super);
        function SubjectSubscriber(destination) {
            var _this = _super.call(this, destination) || this;
            _this.destination = destination;
            return _this;
        }
        return SubjectSubscriber;
    }(Subscriber));
    var Subject = /*@__PURE__*/ (function (_super) {
        __extends(Subject, _super);
        function Subject() {
            var _this = _super.call(this) || this;
            _this.observers = [];
            _this.closed = false;
            _this.isStopped = false;
            _this.hasError = false;
            _this.thrownError = null;
            return _this;
        }
        Subject.prototype[rxSubscriber] = function () {
            return new SubjectSubscriber(this);
        };
        Subject.prototype.lift = function (operator) {
            var subject = new AnonymousSubject(this, this);
            subject.operator = operator;
            return subject;
        };
        Subject.prototype.next = function (value) {
            if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            if (!this.isStopped) {
                var observers = this.observers;
                var len = observers.length;
                var copy = observers.slice();
                for (var i = 0; i < len; i++) {
                    copy[i].next(value);
                }
            }
        };
        Subject.prototype.error = function (err) {
            if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            this.hasError = true;
            this.thrownError = err;
            this.isStopped = true;
            var observers = this.observers;
            var len = observers.length;
            var copy = observers.slice();
            for (var i = 0; i < len; i++) {
                copy[i].error(err);
            }
            this.observers.length = 0;
        };
        Subject.prototype.complete = function () {
            if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            this.isStopped = true;
            var observers = this.observers;
            var len = observers.length;
            var copy = observers.slice();
            for (var i = 0; i < len; i++) {
                copy[i].complete();
            }
            this.observers.length = 0;
        };
        Subject.prototype.unsubscribe = function () {
            this.isStopped = true;
            this.closed = true;
            this.observers = null;
        };
        Subject.prototype._trySubscribe = function (subscriber) {
            if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            else {
                return _super.prototype._trySubscribe.call(this, subscriber);
            }
        };
        Subject.prototype._subscribe = function (subscriber) {
            if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            else if (this.hasError) {
                subscriber.error(this.thrownError);
                return Subscription.EMPTY;
            }
            else if (this.isStopped) {
                subscriber.complete();
                return Subscription.EMPTY;
            }
            else {
                this.observers.push(subscriber);
                return new SubjectSubscription(this, subscriber);
            }
        };
        Subject.prototype.asObservable = function () {
            var observable = new Observable();
            observable.source = this;
            return observable;
        };
        Subject.create = function (destination, source) {
            return new AnonymousSubject(destination, source);
        };
        return Subject;
    }(Observable));
    var AnonymousSubject = /*@__PURE__*/ (function (_super) {
        __extends(AnonymousSubject, _super);
        function AnonymousSubject(destination, source) {
            var _this = _super.call(this) || this;
            _this.destination = destination;
            _this.source = source;
            return _this;
        }
        AnonymousSubject.prototype.next = function (value) {
            var destination = this.destination;
            if (destination && destination.next) {
                destination.next(value);
            }
        };
        AnonymousSubject.prototype.error = function (err) {
            var destination = this.destination;
            if (destination && destination.error) {
                this.destination.error(err);
            }
        };
        AnonymousSubject.prototype.complete = function () {
            var destination = this.destination;
            if (destination && destination.complete) {
                this.destination.complete();
            }
        };
        AnonymousSubject.prototype._subscribe = function (subscriber) {
            var source = this.source;
            if (source) {
                return this.source.subscribe(subscriber);
            }
            else {
                return Subscription.EMPTY;
            }
        };
        return AnonymousSubject;
    }(Subject));

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function refCount() {
        return function refCountOperatorFunction(source) {
            return source.lift(new RefCountOperator(source));
        };
    }
    var RefCountOperator = /*@__PURE__*/ (function () {
        function RefCountOperator(connectable) {
            this.connectable = connectable;
        }
        RefCountOperator.prototype.call = function (subscriber, source) {
            var connectable = this.connectable;
            connectable._refCount++;
            var refCounter = new RefCountSubscriber(subscriber, connectable);
            var subscription = source.subscribe(refCounter);
            if (!refCounter.closed) {
                refCounter.connection = connectable.connect();
            }
            return subscription;
        };
        return RefCountOperator;
    }());
    var RefCountSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(RefCountSubscriber, _super);
        function RefCountSubscriber(destination, connectable) {
            var _this = _super.call(this, destination) || this;
            _this.connectable = connectable;
            return _this;
        }
        RefCountSubscriber.prototype._unsubscribe = function () {
            var connectable = this.connectable;
            if (!connectable) {
                this.connection = null;
                return;
            }
            this.connectable = null;
            var refCount = connectable._refCount;
            if (refCount <= 0) {
                this.connection = null;
                return;
            }
            connectable._refCount = refCount - 1;
            if (refCount > 1) {
                this.connection = null;
                return;
            }
            var connection = this.connection;
            var sharedConnection = connectable._connection;
            this.connection = null;
            if (sharedConnection && (!connection || sharedConnection === connection)) {
                sharedConnection.unsubscribe();
            }
        };
        return RefCountSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_Subject,_Observable,_Subscriber,_Subscription,_operators_refCount PURE_IMPORTS_END */
    var ConnectableObservable = /*@__PURE__*/ (function (_super) {
        __extends(ConnectableObservable, _super);
        function ConnectableObservable(source, subjectFactory) {
            var _this = _super.call(this) || this;
            _this.source = source;
            _this.subjectFactory = subjectFactory;
            _this._refCount = 0;
            _this._isComplete = false;
            return _this;
        }
        ConnectableObservable.prototype._subscribe = function (subscriber) {
            return this.getSubject().subscribe(subscriber);
        };
        ConnectableObservable.prototype.getSubject = function () {
            var subject = this._subject;
            if (!subject || subject.isStopped) {
                this._subject = this.subjectFactory();
            }
            return this._subject;
        };
        ConnectableObservable.prototype.connect = function () {
            var connection = this._connection;
            if (!connection) {
                this._isComplete = false;
                connection = this._connection = new Subscription();
                connection.add(this.source
                    .subscribe(new ConnectableSubscriber(this.getSubject(), this)));
                if (connection.closed) {
                    this._connection = null;
                    connection = Subscription.EMPTY;
                }
            }
            return connection;
        };
        ConnectableObservable.prototype.refCount = function () {
            return refCount()(this);
        };
        return ConnectableObservable;
    }(Observable));
    var connectableObservableDescriptor = /*@__PURE__*/ (function () {
        var connectableProto = ConnectableObservable.prototype;
        return {
            operator: { value: null },
            _refCount: { value: 0, writable: true },
            _subject: { value: null, writable: true },
            _connection: { value: null, writable: true },
            _subscribe: { value: connectableProto._subscribe },
            _isComplete: { value: connectableProto._isComplete, writable: true },
            getSubject: { value: connectableProto.getSubject },
            connect: { value: connectableProto.connect },
            refCount: { value: connectableProto.refCount }
        };
    })();
    var ConnectableSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(ConnectableSubscriber, _super);
        function ConnectableSubscriber(destination, connectable) {
            var _this = _super.call(this, destination) || this;
            _this.connectable = connectable;
            return _this;
        }
        ConnectableSubscriber.prototype._error = function (err) {
            this._unsubscribe();
            _super.prototype._error.call(this, err);
        };
        ConnectableSubscriber.prototype._complete = function () {
            this.connectable._isComplete = true;
            this._unsubscribe();
            _super.prototype._complete.call(this);
        };
        ConnectableSubscriber.prototype._unsubscribe = function () {
            var connectable = this.connectable;
            if (connectable) {
                this.connectable = null;
                var connection = connectable._connection;
                connectable._refCount = 0;
                connectable._subject = null;
                connectable._connection = null;
                if (connection) {
                    connection.unsubscribe();
                }
            }
        };
        return ConnectableSubscriber;
    }(SubjectSubscriber));

    /** PURE_IMPORTS_START tslib,_Subject,_util_ObjectUnsubscribedError PURE_IMPORTS_END */
    var BehaviorSubject = /*@__PURE__*/ (function (_super) {
        __extends(BehaviorSubject, _super);
        function BehaviorSubject(_value) {
            var _this = _super.call(this) || this;
            _this._value = _value;
            return _this;
        }
        Object.defineProperty(BehaviorSubject.prototype, "value", {
            get: function () {
                return this.getValue();
            },
            enumerable: true,
            configurable: true
        });
        BehaviorSubject.prototype._subscribe = function (subscriber) {
            var subscription = _super.prototype._subscribe.call(this, subscriber);
            if (subscription && !subscription.closed) {
                subscriber.next(this._value);
            }
            return subscription;
        };
        BehaviorSubject.prototype.getValue = function () {
            if (this.hasError) {
                throw this.thrownError;
            }
            else if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            else {
                return this._value;
            }
        };
        BehaviorSubject.prototype.next = function (value) {
            _super.prototype.next.call(this, this._value = value);
        };
        return BehaviorSubject;
    }(Subject));

    /** PURE_IMPORTS_START tslib,_Subscription PURE_IMPORTS_END */
    var Action = /*@__PURE__*/ (function (_super) {
        __extends(Action, _super);
        function Action(scheduler, work) {
            return _super.call(this) || this;
        }
        Action.prototype.schedule = function (state, delay) {
            return this;
        };
        return Action;
    }(Subscription));

    /** PURE_IMPORTS_START tslib,_Action PURE_IMPORTS_END */
    var AsyncAction = /*@__PURE__*/ (function (_super) {
        __extends(AsyncAction, _super);
        function AsyncAction(scheduler, work) {
            var _this = _super.call(this, scheduler, work) || this;
            _this.scheduler = scheduler;
            _this.work = work;
            _this.pending = false;
            return _this;
        }
        AsyncAction.prototype.schedule = function (state, delay) {
            if (delay === void 0) {
                delay = 0;
            }
            if (this.closed) {
                return this;
            }
            this.state = state;
            var id = this.id;
            var scheduler = this.scheduler;
            if (id != null) {
                this.id = this.recycleAsyncId(scheduler, id, delay);
            }
            this.pending = true;
            this.delay = delay;
            this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
            return this;
        };
        AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {
            if (delay === void 0) {
                delay = 0;
            }
            return setInterval(scheduler.flush.bind(scheduler, this), delay);
        };
        AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {
            if (delay === void 0) {
                delay = 0;
            }
            if (delay !== null && this.delay === delay && this.pending === false) {
                return id;
            }
            clearInterval(id);
            return undefined;
        };
        AsyncAction.prototype.execute = function (state, delay) {
            if (this.closed) {
                return new Error('executing a cancelled action');
            }
            this.pending = false;
            var error = this._execute(state, delay);
            if (error) {
                return error;
            }
            else if (this.pending === false && this.id != null) {
                this.id = this.recycleAsyncId(this.scheduler, this.id, null);
            }
        };
        AsyncAction.prototype._execute = function (state, delay) {
            var errored = false;
            var errorValue = undefined;
            try {
                this.work(state);
            }
            catch (e) {
                errored = true;
                errorValue = !!e && e || new Error(e);
            }
            if (errored) {
                this.unsubscribe();
                return errorValue;
            }
        };
        AsyncAction.prototype._unsubscribe = function () {
            var id = this.id;
            var scheduler = this.scheduler;
            var actions = scheduler.actions;
            var index = actions.indexOf(this);
            this.work = null;
            this.state = null;
            this.pending = false;
            this.scheduler = null;
            if (index !== -1) {
                actions.splice(index, 1);
            }
            if (id != null) {
                this.id = this.recycleAsyncId(scheduler, id, null);
            }
            this.delay = null;
        };
        return AsyncAction;
    }(Action));

    /** PURE_IMPORTS_START tslib,_AsyncAction PURE_IMPORTS_END */
    var QueueAction = /*@__PURE__*/ (function (_super) {
        __extends(QueueAction, _super);
        function QueueAction(scheduler, work) {
            var _this = _super.call(this, scheduler, work) || this;
            _this.scheduler = scheduler;
            _this.work = work;
            return _this;
        }
        QueueAction.prototype.schedule = function (state, delay) {
            if (delay === void 0) {
                delay = 0;
            }
            if (delay > 0) {
                return _super.prototype.schedule.call(this, state, delay);
            }
            this.delay = delay;
            this.state = state;
            this.scheduler.flush(this);
            return this;
        };
        QueueAction.prototype.execute = function (state, delay) {
            return (delay > 0 || this.closed) ?
                _super.prototype.execute.call(this, state, delay) :
                this._execute(state, delay);
        };
        QueueAction.prototype.requestAsyncId = function (scheduler, id, delay) {
            if (delay === void 0) {
                delay = 0;
            }
            if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
                return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);
            }
            return scheduler.flush(this);
        };
        return QueueAction;
    }(AsyncAction));

    var Scheduler = /*@__PURE__*/ (function () {
        function Scheduler(SchedulerAction, now) {
            if (now === void 0) {
                now = Scheduler.now;
            }
            this.SchedulerAction = SchedulerAction;
            this.now = now;
        }
        Scheduler.prototype.schedule = function (work, delay, state) {
            if (delay === void 0) {
                delay = 0;
            }
            return new this.SchedulerAction(this, work).schedule(state, delay);
        };
        Scheduler.now = function () { return Date.now(); };
        return Scheduler;
    }());

    /** PURE_IMPORTS_START tslib,_Scheduler PURE_IMPORTS_END */
    var AsyncScheduler = /*@__PURE__*/ (function (_super) {
        __extends(AsyncScheduler, _super);
        function AsyncScheduler(SchedulerAction, now) {
            if (now === void 0) {
                now = Scheduler.now;
            }
            var _this = _super.call(this, SchedulerAction, function () {
                if (AsyncScheduler.delegate && AsyncScheduler.delegate !== _this) {
                    return AsyncScheduler.delegate.now();
                }
                else {
                    return now();
                }
            }) || this;
            _this.actions = [];
            _this.active = false;
            _this.scheduled = undefined;
            return _this;
        }
        AsyncScheduler.prototype.schedule = function (work, delay, state) {
            if (delay === void 0) {
                delay = 0;
            }
            if (AsyncScheduler.delegate && AsyncScheduler.delegate !== this) {
                return AsyncScheduler.delegate.schedule(work, delay, state);
            }
            else {
                return _super.prototype.schedule.call(this, work, delay, state);
            }
        };
        AsyncScheduler.prototype.flush = function (action) {
            var actions = this.actions;
            if (this.active) {
                actions.push(action);
                return;
            }
            var error;
            this.active = true;
            do {
                if (error = action.execute(action.state, action.delay)) {
                    break;
                }
            } while (action = actions.shift());
            this.active = false;
            if (error) {
                while (action = actions.shift()) {
                    action.unsubscribe();
                }
                throw error;
            }
        };
        return AsyncScheduler;
    }(Scheduler));

    /** PURE_IMPORTS_START tslib,_AsyncScheduler PURE_IMPORTS_END */
    var QueueScheduler = /*@__PURE__*/ (function (_super) {
        __extends(QueueScheduler, _super);
        function QueueScheduler() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        return QueueScheduler;
    }(AsyncScheduler));

    /** PURE_IMPORTS_START _QueueAction,_QueueScheduler PURE_IMPORTS_END */
    var queueScheduler = /*@__PURE__*/ new QueueScheduler(QueueAction);
    var queue = queueScheduler;

    /** PURE_IMPORTS_START _Observable PURE_IMPORTS_END */
    var EMPTY$1 = /*@__PURE__*/ new Observable(function (subscriber) { return subscriber.complete(); });
    function empty(scheduler) {
        return scheduler ? emptyScheduled(scheduler) : EMPTY$1;
    }
    function emptyScheduled(scheduler) {
        return new Observable(function (subscriber) { return scheduler.schedule(function () { return subscriber.complete(); }); });
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function isScheduler(value) {
        return value && typeof value.schedule === 'function';
    }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var subscribeToArray = function (array) {
        return function (subscriber) {
            for (var i = 0, len = array.length; i < len && !subscriber.closed; i++) {
                subscriber.next(array[i]);
            }
            subscriber.complete();
        };
    };

    /** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */
    function scheduleArray(input, scheduler) {
        return new Observable(function (subscriber) {
            var sub = new Subscription();
            var i = 0;
            sub.add(scheduler.schedule(function () {
                if (i === input.length) {
                    subscriber.complete();
                    return;
                }
                subscriber.next(input[i++]);
                if (!subscriber.closed) {
                    sub.add(this.schedule());
                }
            }));
            return sub;
        });
    }

    /** PURE_IMPORTS_START _Observable,_util_subscribeToArray,_scheduled_scheduleArray PURE_IMPORTS_END */
    function fromArray(input, scheduler) {
        if (!scheduler) {
            return new Observable(subscribeToArray(input));
        }
        else {
            return scheduleArray(input, scheduler);
        }
    }

    /** PURE_IMPORTS_START _util_isScheduler,_fromArray,_scheduled_scheduleArray PURE_IMPORTS_END */
    function of() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        var scheduler = args[args.length - 1];
        if (isScheduler(scheduler)) {
            args.pop();
            return scheduleArray(args, scheduler);
        }
        else {
            return fromArray(args);
        }
    }

    /** PURE_IMPORTS_START _Observable PURE_IMPORTS_END */
    function throwError(error, scheduler) {
        if (!scheduler) {
            return new Observable(function (subscriber) { return subscriber.error(error); });
        }
        else {
            return new Observable(function (subscriber) { return scheduler.schedule(dispatch$1, 0, { error: error, subscriber: subscriber }); });
        }
    }
    function dispatch$1(_a) {
        var error = _a.error, subscriber = _a.subscriber;
        subscriber.error(error);
    }

    /** PURE_IMPORTS_START _observable_empty,_observable_of,_observable_throwError PURE_IMPORTS_END */
    var Notification = /*@__PURE__*/ (function () {
        function Notification(kind, value, error) {
            this.kind = kind;
            this.value = value;
            this.error = error;
            this.hasValue = kind === 'N';
        }
        Notification.prototype.observe = function (observer) {
            switch (this.kind) {
                case 'N':
                    return observer.next && observer.next(this.value);
                case 'E':
                    return observer.error && observer.error(this.error);
                case 'C':
                    return observer.complete && observer.complete();
            }
        };
        Notification.prototype.do = function (next, error, complete) {
            var kind = this.kind;
            switch (kind) {
                case 'N':
                    return next && next(this.value);
                case 'E':
                    return error && error(this.error);
                case 'C':
                    return complete && complete();
            }
        };
        Notification.prototype.accept = function (nextOrObserver, error, complete) {
            if (nextOrObserver && typeof nextOrObserver.next === 'function') {
                return this.observe(nextOrObserver);
            }
            else {
                return this.do(nextOrObserver, error, complete);
            }
        };
        Notification.prototype.toObservable = function () {
            var kind = this.kind;
            switch (kind) {
                case 'N':
                    return of(this.value);
                case 'E':
                    return throwError(this.error);
                case 'C':
                    return empty();
            }
            throw new Error('unexpected notification kind value');
        };
        Notification.createNext = function (value) {
            if (typeof value !== 'undefined') {
                return new Notification('N', value);
            }
            return Notification.undefinedValueNotification;
        };
        Notification.createError = function (err) {
            return new Notification('E', undefined, err);
        };
        Notification.createComplete = function () {
            return Notification.completeNotification;
        };
        Notification.completeNotification = new Notification('C');
        Notification.undefinedValueNotification = new Notification('N', undefined);
        return Notification;
    }());

    /** PURE_IMPORTS_START tslib,_Subscriber,_Notification PURE_IMPORTS_END */
    var ObserveOnSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(ObserveOnSubscriber, _super);
        function ObserveOnSubscriber(destination, scheduler, delay) {
            if (delay === void 0) {
                delay = 0;
            }
            var _this = _super.call(this, destination) || this;
            _this.scheduler = scheduler;
            _this.delay = delay;
            return _this;
        }
        ObserveOnSubscriber.dispatch = function (arg) {
            var notification = arg.notification, destination = arg.destination;
            notification.observe(destination);
            this.unsubscribe();
        };
        ObserveOnSubscriber.prototype.scheduleMessage = function (notification) {
            var destination = this.destination;
            destination.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));
        };
        ObserveOnSubscriber.prototype._next = function (value) {
            this.scheduleMessage(Notification.createNext(value));
        };
        ObserveOnSubscriber.prototype._error = function (err) {
            this.scheduleMessage(Notification.createError(err));
            this.unsubscribe();
        };
        ObserveOnSubscriber.prototype._complete = function () {
            this.scheduleMessage(Notification.createComplete());
            this.unsubscribe();
        };
        return ObserveOnSubscriber;
    }(Subscriber));
    var ObserveOnMessage = /*@__PURE__*/ (function () {
        function ObserveOnMessage(notification, destination) {
            this.notification = notification;
            this.destination = destination;
        }
        return ObserveOnMessage;
    }());

    /** PURE_IMPORTS_START tslib,_Subject,_scheduler_queue,_Subscription,_operators_observeOn,_util_ObjectUnsubscribedError,_SubjectSubscription PURE_IMPORTS_END */
    var ReplaySubject = /*@__PURE__*/ (function (_super) {
        __extends(ReplaySubject, _super);
        function ReplaySubject(bufferSize, windowTime, scheduler) {
            if (bufferSize === void 0) {
                bufferSize = Number.POSITIVE_INFINITY;
            }
            if (windowTime === void 0) {
                windowTime = Number.POSITIVE_INFINITY;
            }
            var _this = _super.call(this) || this;
            _this.scheduler = scheduler;
            _this._events = [];
            _this._infiniteTimeWindow = false;
            _this._bufferSize = bufferSize < 1 ? 1 : bufferSize;
            _this._windowTime = windowTime < 1 ? 1 : windowTime;
            if (windowTime === Number.POSITIVE_INFINITY) {
                _this._infiniteTimeWindow = true;
                _this.next = _this.nextInfiniteTimeWindow;
            }
            else {
                _this.next = _this.nextTimeWindow;
            }
            return _this;
        }
        ReplaySubject.prototype.nextInfiniteTimeWindow = function (value) {
            if (!this.isStopped) {
                var _events = this._events;
                _events.push(value);
                if (_events.length > this._bufferSize) {
                    _events.shift();
                }
            }
            _super.prototype.next.call(this, value);
        };
        ReplaySubject.prototype.nextTimeWindow = function (value) {
            if (!this.isStopped) {
                this._events.push(new ReplayEvent(this._getNow(), value));
                this._trimBufferThenGetEvents();
            }
            _super.prototype.next.call(this, value);
        };
        ReplaySubject.prototype._subscribe = function (subscriber) {
            var _infiniteTimeWindow = this._infiniteTimeWindow;
            var _events = _infiniteTimeWindow ? this._events : this._trimBufferThenGetEvents();
            var scheduler = this.scheduler;
            var len = _events.length;
            var subscription;
            if (this.closed) {
                throw new ObjectUnsubscribedError();
            }
            else if (this.isStopped || this.hasError) {
                subscription = Subscription.EMPTY;
            }
            else {
                this.observers.push(subscriber);
                subscription = new SubjectSubscription(this, subscriber);
            }
            if (scheduler) {
                subscriber.add(subscriber = new ObserveOnSubscriber(subscriber, scheduler));
            }
            if (_infiniteTimeWindow) {
                for (var i = 0; i < len && !subscriber.closed; i++) {
                    subscriber.next(_events[i]);
                }
            }
            else {
                for (var i = 0; i < len && !subscriber.closed; i++) {
                    subscriber.next(_events[i].value);
                }
            }
            if (this.hasError) {
                subscriber.error(this.thrownError);
            }
            else if (this.isStopped) {
                subscriber.complete();
            }
            return subscription;
        };
        ReplaySubject.prototype._getNow = function () {
            return (this.scheduler || queue).now();
        };
        ReplaySubject.prototype._trimBufferThenGetEvents = function () {
            var now = this._getNow();
            var _bufferSize = this._bufferSize;
            var _windowTime = this._windowTime;
            var _events = this._events;
            var eventsCount = _events.length;
            var spliceCount = 0;
            while (spliceCount < eventsCount) {
                if ((now - _events[spliceCount].time) < _windowTime) {
                    break;
                }
                spliceCount++;
            }
            if (eventsCount > _bufferSize) {
                spliceCount = Math.max(spliceCount, eventsCount - _bufferSize);
            }
            if (spliceCount > 0) {
                _events.splice(0, spliceCount);
            }
            return _events;
        };
        return ReplaySubject;
    }(Subject));
    var ReplayEvent = /*@__PURE__*/ (function () {
        function ReplayEvent(time, value) {
            this.time = time;
            this.value = value;
        }
        return ReplayEvent;
    }());

    /** PURE_IMPORTS_START _AsyncAction,_AsyncScheduler PURE_IMPORTS_END */
    var asyncScheduler = /*@__PURE__*/ new AsyncScheduler(AsyncAction);
    var async = asyncScheduler;

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function noop() { }

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var ArgumentOutOfRangeErrorImpl = /*@__PURE__*/ (function () {
        function ArgumentOutOfRangeErrorImpl() {
            Error.call(this);
            this.message = 'argument out of range';
            this.name = 'ArgumentOutOfRangeError';
            return this;
        }
        ArgumentOutOfRangeErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);
        return ArgumentOutOfRangeErrorImpl;
    })();
    var ArgumentOutOfRangeError = ArgumentOutOfRangeErrorImpl;

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var EmptyErrorImpl = /*@__PURE__*/ (function () {
        function EmptyErrorImpl() {
            Error.call(this);
            this.message = 'no elements in sequence';
            this.name = 'EmptyError';
            return this;
        }
        EmptyErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);
        return EmptyErrorImpl;
    })();
    var EmptyError = EmptyErrorImpl;

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var TimeoutErrorImpl = /*@__PURE__*/ (function () {
        function TimeoutErrorImpl() {
            Error.call(this);
            this.message = 'Timeout has occurred';
            this.name = 'TimeoutError';
            return this;
        }
        TimeoutErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);
        return TimeoutErrorImpl;
    })();
    var TimeoutError = TimeoutErrorImpl;

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function map(project, thisArg) {
        return function mapOperation(source) {
            if (typeof project !== 'function') {
                throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
            }
            return source.lift(new MapOperator(project, thisArg));
        };
    }
    var MapOperator = /*@__PURE__*/ (function () {
        function MapOperator(project, thisArg) {
            this.project = project;
            this.thisArg = thisArg;
        }
        MapOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
        };
        return MapOperator;
    }());
    var MapSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(MapSubscriber, _super);
        function MapSubscriber(destination, project, thisArg) {
            var _this = _super.call(this, destination) || this;
            _this.project = project;
            _this.count = 0;
            _this.thisArg = thisArg || _this;
            return _this;
        }
        MapSubscriber.prototype._next = function (value) {
            var result;
            try {
                result = this.project.call(this.thisArg, value, this.count++);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.destination.next(result);
        };
        return MapSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    var OuterSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(OuterSubscriber, _super);
        function OuterSubscriber() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
            this.destination.next(innerValue);
        };
        OuterSubscriber.prototype.notifyError = function (error, innerSub) {
            this.destination.error(error);
        };
        OuterSubscriber.prototype.notifyComplete = function (innerSub) {
            this.destination.complete();
        };
        return OuterSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    var InnerSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(InnerSubscriber, _super);
        function InnerSubscriber(parent, outerValue, outerIndex) {
            var _this = _super.call(this) || this;
            _this.parent = parent;
            _this.outerValue = outerValue;
            _this.outerIndex = outerIndex;
            _this.index = 0;
            return _this;
        }
        InnerSubscriber.prototype._next = function (value) {
            this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);
        };
        InnerSubscriber.prototype._error = function (error) {
            this.parent.notifyError(error, this);
            this.unsubscribe();
        };
        InnerSubscriber.prototype._complete = function () {
            this.parent.notifyComplete(this);
            this.unsubscribe();
        };
        return InnerSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _hostReportError PURE_IMPORTS_END */
    var subscribeToPromise = function (promise) {
        return function (subscriber) {
            promise.then(function (value) {
                if (!subscriber.closed) {
                    subscriber.next(value);
                    subscriber.complete();
                }
            }, function (err) { return subscriber.error(err); })
                .then(null, hostReportError);
            return subscriber;
        };
    };

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function getSymbolIterator() {
        if (typeof Symbol !== 'function' || !Symbol.iterator) {
            return '@@iterator';
        }
        return Symbol.iterator;
    }
    var iterator = /*@__PURE__*/ getSymbolIterator();

    /** PURE_IMPORTS_START _symbol_iterator PURE_IMPORTS_END */
    var subscribeToIterable = function (iterable) {
        return function (subscriber) {
            var iterator$1 = iterable[iterator]();
            do {
                var item = void 0;
                try {
                    item = iterator$1.next();
                }
                catch (err) {
                    subscriber.error(err);
                    return subscriber;
                }
                if (item.done) {
                    subscriber.complete();
                    break;
                }
                subscriber.next(item.value);
                if (subscriber.closed) {
                    break;
                }
            } while (true);
            if (typeof iterator$1.return === 'function') {
                subscriber.add(function () {
                    if (iterator$1.return) {
                        iterator$1.return();
                    }
                });
            }
            return subscriber;
        };
    };

    /** PURE_IMPORTS_START _symbol_observable PURE_IMPORTS_END */
    var subscribeToObservable = function (obj) {
        return function (subscriber) {
            var obs = obj[observable]();
            if (typeof obs.subscribe !== 'function') {
                throw new TypeError('Provided object does not correctly implement Symbol.observable');
            }
            else {
                return obs.subscribe(subscriber);
            }
        };
    };

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function isPromise(value) {
        return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
    }

    /** PURE_IMPORTS_START _subscribeToArray,_subscribeToPromise,_subscribeToIterable,_subscribeToObservable,_isArrayLike,_isPromise,_isObject,_symbol_iterator,_symbol_observable PURE_IMPORTS_END */
    var subscribeTo = function (result) {
        if (!!result && typeof result[observable] === 'function') {
            return subscribeToObservable(result);
        }
        else if (isArrayLike(result)) {
            return subscribeToArray(result);
        }
        else if (isPromise(result)) {
            return subscribeToPromise(result);
        }
        else if (!!result && typeof result[iterator] === 'function') {
            return subscribeToIterable(result);
        }
        else {
            var value = isObject$1(result) ? 'an invalid object' : "'" + result + "'";
            var msg = "You provided " + value + " where a stream was expected."
                + ' You can provide an Observable, Promise, Array, or Iterable.';
            throw new TypeError(msg);
        }
    };

    /** PURE_IMPORTS_START _InnerSubscriber,_subscribeTo,_Observable PURE_IMPORTS_END */
    function subscribeToResult(outerSubscriber, result, outerValue, outerIndex, innerSubscriber) {
        if (innerSubscriber === void 0) {
            innerSubscriber = new InnerSubscriber(outerSubscriber, outerValue, outerIndex);
        }
        if (innerSubscriber.closed) {
            return undefined;
        }
        if (result instanceof Observable) {
            return result.subscribe(innerSubscriber);
        }
        return subscribeTo(result)(innerSubscriber);
    }

    /** PURE_IMPORTS_START tslib,_util_isScheduler,_util_isArray,_OuterSubscriber,_util_subscribeToResult,_fromArray PURE_IMPORTS_END */
    var NONE = {};
    function combineLatest() {
        var observables = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            observables[_i] = arguments[_i];
        }
        var resultSelector = undefined;
        var scheduler = undefined;
        if (isScheduler(observables[observables.length - 1])) {
            scheduler = observables.pop();
        }
        if (typeof observables[observables.length - 1] === 'function') {
            resultSelector = observables.pop();
        }
        if (observables.length === 1 && isArray$1(observables[0])) {
            observables = observables[0];
        }
        return fromArray(observables, scheduler).lift(new CombineLatestOperator(resultSelector));
    }
    var CombineLatestOperator = /*@__PURE__*/ (function () {
        function CombineLatestOperator(resultSelector) {
            this.resultSelector = resultSelector;
        }
        CombineLatestOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new CombineLatestSubscriber(subscriber, this.resultSelector));
        };
        return CombineLatestOperator;
    }());
    var CombineLatestSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(CombineLatestSubscriber, _super);
        function CombineLatestSubscriber(destination, resultSelector) {
            var _this = _super.call(this, destination) || this;
            _this.resultSelector = resultSelector;
            _this.active = 0;
            _this.values = [];
            _this.observables = [];
            return _this;
        }
        CombineLatestSubscriber.prototype._next = function (observable) {
            this.values.push(NONE);
            this.observables.push(observable);
        };
        CombineLatestSubscriber.prototype._complete = function () {
            var observables = this.observables;
            var len = observables.length;
            if (len === 0) {
                this.destination.complete();
            }
            else {
                this.active = len;
                this.toRespond = len;
                for (var i = 0; i < len; i++) {
                    var observable = observables[i];
                    this.add(subscribeToResult(this, observable, undefined, i));
                }
            }
        };
        CombineLatestSubscriber.prototype.notifyComplete = function (unused) {
            if ((this.active -= 1) === 0) {
                this.destination.complete();
            }
        };
        CombineLatestSubscriber.prototype.notifyNext = function (_outerValue, innerValue, outerIndex) {
            var values = this.values;
            var oldVal = values[outerIndex];
            var toRespond = !this.toRespond
                ? 0
                : oldVal === NONE ? --this.toRespond : this.toRespond;
            values[outerIndex] = innerValue;
            if (toRespond === 0) {
                if (this.resultSelector) {
                    this._tryResultSelector(values);
                }
                else {
                    this.destination.next(values.slice());
                }
            }
        };
        CombineLatestSubscriber.prototype._tryResultSelector = function (values) {
            var result;
            try {
                result = this.resultSelector.apply(this, values);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.destination.next(result);
        };
        return CombineLatestSubscriber;
    }(OuterSubscriber));

    /** PURE_IMPORTS_START _Observable,_Subscription,_symbol_observable PURE_IMPORTS_END */
    function scheduleObservable(input, scheduler) {
        return new Observable(function (subscriber) {
            var sub = new Subscription();
            sub.add(scheduler.schedule(function () {
                var observable$1 = input[observable]();
                sub.add(observable$1.subscribe({
                    next: function (value) { sub.add(scheduler.schedule(function () { return subscriber.next(value); })); },
                    error: function (err) { sub.add(scheduler.schedule(function () { return subscriber.error(err); })); },
                    complete: function () { sub.add(scheduler.schedule(function () { return subscriber.complete(); })); },
                }));
            }));
            return sub;
        });
    }

    /** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */
    function schedulePromise(input, scheduler) {
        return new Observable(function (subscriber) {
            var sub = new Subscription();
            sub.add(scheduler.schedule(function () {
                return input.then(function (value) {
                    sub.add(scheduler.schedule(function () {
                        subscriber.next(value);
                        sub.add(scheduler.schedule(function () { return subscriber.complete(); }));
                    }));
                }, function (err) {
                    sub.add(scheduler.schedule(function () { return subscriber.error(err); }));
                });
            }));
            return sub;
        });
    }

    /** PURE_IMPORTS_START _Observable,_Subscription,_symbol_iterator PURE_IMPORTS_END */
    function scheduleIterable(input, scheduler) {
        if (!input) {
            throw new Error('Iterable cannot be null');
        }
        return new Observable(function (subscriber) {
            var sub = new Subscription();
            var iterator$1;
            sub.add(function () {
                if (iterator$1 && typeof iterator$1.return === 'function') {
                    iterator$1.return();
                }
            });
            sub.add(scheduler.schedule(function () {
                iterator$1 = input[iterator]();
                sub.add(scheduler.schedule(function () {
                    if (subscriber.closed) {
                        return;
                    }
                    var value;
                    var done;
                    try {
                        var result = iterator$1.next();
                        value = result.value;
                        done = result.done;
                    }
                    catch (err) {
                        subscriber.error(err);
                        return;
                    }
                    if (done) {
                        subscriber.complete();
                    }
                    else {
                        subscriber.next(value);
                        this.schedule();
                    }
                }));
            }));
            return sub;
        });
    }

    /** PURE_IMPORTS_START _symbol_observable PURE_IMPORTS_END */
    function isInteropObservable(input) {
        return input && typeof input[observable] === 'function';
    }

    /** PURE_IMPORTS_START _symbol_iterator PURE_IMPORTS_END */
    function isIterable(input) {
        return input && typeof input[iterator] === 'function';
    }

    /** PURE_IMPORTS_START _scheduleObservable,_schedulePromise,_scheduleArray,_scheduleIterable,_util_isInteropObservable,_util_isPromise,_util_isArrayLike,_util_isIterable PURE_IMPORTS_END */
    function scheduled(input, scheduler) {
        if (input != null) {
            if (isInteropObservable(input)) {
                return scheduleObservable(input, scheduler);
            }
            else if (isPromise(input)) {
                return schedulePromise(input, scheduler);
            }
            else if (isArrayLike(input)) {
                return scheduleArray(input, scheduler);
            }
            else if (isIterable(input) || typeof input === 'string') {
                return scheduleIterable(input, scheduler);
            }
        }
        throw new TypeError((input !== null && typeof input || input) + ' is not observable');
    }

    /** PURE_IMPORTS_START _Observable,_util_subscribeTo,_scheduled_scheduled PURE_IMPORTS_END */
    function from(input, scheduler) {
        if (!scheduler) {
            if (input instanceof Observable) {
                return input;
            }
            return new Observable(subscribeTo(input));
        }
        else {
            return scheduled(input, scheduler);
        }
    }

    /** PURE_IMPORTS_START tslib,_Subscriber,_Observable,_util_subscribeTo PURE_IMPORTS_END */
    var SimpleInnerSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SimpleInnerSubscriber, _super);
        function SimpleInnerSubscriber(parent) {
            var _this = _super.call(this) || this;
            _this.parent = parent;
            return _this;
        }
        SimpleInnerSubscriber.prototype._next = function (value) {
            this.parent.notifyNext(value);
        };
        SimpleInnerSubscriber.prototype._error = function (error) {
            this.parent.notifyError(error);
            this.unsubscribe();
        };
        SimpleInnerSubscriber.prototype._complete = function () {
            this.parent.notifyComplete();
            this.unsubscribe();
        };
        return SimpleInnerSubscriber;
    }(Subscriber));
    var SimpleOuterSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SimpleOuterSubscriber, _super);
        function SimpleOuterSubscriber() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        SimpleOuterSubscriber.prototype.notifyNext = function (innerValue) {
            this.destination.next(innerValue);
        };
        SimpleOuterSubscriber.prototype.notifyError = function (err) {
            this.destination.error(err);
        };
        SimpleOuterSubscriber.prototype.notifyComplete = function () {
            this.destination.complete();
        };
        return SimpleOuterSubscriber;
    }(Subscriber));
    function innerSubscribe(result, innerSubscriber) {
        if (innerSubscriber.closed) {
            return undefined;
        }
        if (result instanceof Observable) {
            return result.subscribe(innerSubscriber);
        }
        return subscribeTo(result)(innerSubscriber);
    }

    /** PURE_IMPORTS_START tslib,_map,_observable_from,_innerSubscribe PURE_IMPORTS_END */
    function mergeMap(project, resultSelector, concurrent) {
        if (concurrent === void 0) {
            concurrent = Number.POSITIVE_INFINITY;
        }
        if (typeof resultSelector === 'function') {
            return function (source) { return source.pipe(mergeMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); }, concurrent)); };
        }
        else if (typeof resultSelector === 'number') {
            concurrent = resultSelector;
        }
        return function (source) { return source.lift(new MergeMapOperator(project, concurrent)); };
    }
    var MergeMapOperator = /*@__PURE__*/ (function () {
        function MergeMapOperator(project, concurrent) {
            if (concurrent === void 0) {
                concurrent = Number.POSITIVE_INFINITY;
            }
            this.project = project;
            this.concurrent = concurrent;
        }
        MergeMapOperator.prototype.call = function (observer, source) {
            return source.subscribe(new MergeMapSubscriber(observer, this.project, this.concurrent));
        };
        return MergeMapOperator;
    }());
    var MergeMapSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(MergeMapSubscriber, _super);
        function MergeMapSubscriber(destination, project, concurrent) {
            if (concurrent === void 0) {
                concurrent = Number.POSITIVE_INFINITY;
            }
            var _this = _super.call(this, destination) || this;
            _this.project = project;
            _this.concurrent = concurrent;
            _this.hasCompleted = false;
            _this.buffer = [];
            _this.active = 0;
            _this.index = 0;
            return _this;
        }
        MergeMapSubscriber.prototype._next = function (value) {
            if (this.active < this.concurrent) {
                this._tryNext(value);
            }
            else {
                this.buffer.push(value);
            }
        };
        MergeMapSubscriber.prototype._tryNext = function (value) {
            var result;
            var index = this.index++;
            try {
                result = this.project(value, index);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.active++;
            this._innerSub(result);
        };
        MergeMapSubscriber.prototype._innerSub = function (ish) {
            var innerSubscriber = new SimpleInnerSubscriber(this);
            var destination = this.destination;
            destination.add(innerSubscriber);
            var innerSubscription = innerSubscribe(ish, innerSubscriber);
            if (innerSubscription !== innerSubscriber) {
                destination.add(innerSubscription);
            }
        };
        MergeMapSubscriber.prototype._complete = function () {
            this.hasCompleted = true;
            if (this.active === 0 && this.buffer.length === 0) {
                this.destination.complete();
            }
            this.unsubscribe();
        };
        MergeMapSubscriber.prototype.notifyNext = function (innerValue) {
            this.destination.next(innerValue);
        };
        MergeMapSubscriber.prototype.notifyComplete = function () {
            var buffer = this.buffer;
            this.active--;
            if (buffer.length > 0) {
                this._next(buffer.shift());
            }
            else if (this.active === 0 && this.hasCompleted) {
                this.destination.complete();
            }
        };
        return MergeMapSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START _mergeMap,_util_identity PURE_IMPORTS_END */
    function mergeAll(concurrent) {
        if (concurrent === void 0) {
            concurrent = Number.POSITIVE_INFINITY;
        }
        return mergeMap(identity, concurrent);
    }

    /** PURE_IMPORTS_START _mergeAll PURE_IMPORTS_END */
    function concatAll() {
        return mergeAll(1);
    }

    /** PURE_IMPORTS_START _of,_operators_concatAll PURE_IMPORTS_END */
    function concat() {
        var observables = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            observables[_i] = arguments[_i];
        }
        return concatAll()(of.apply(void 0, observables));
    }

    /** PURE_IMPORTS_START _Observable,_util_isArray,_util_isFunction,_operators_map PURE_IMPORTS_END */
    function fromEvent(target, eventName, options, resultSelector) {
        if (isFunction(options)) {
            resultSelector = options;
            options = undefined;
        }
        if (resultSelector) {
            return fromEvent(target, eventName, options).pipe(map(function (args) { return isArray$1(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));
        }
        return new Observable(function (subscriber) {
            function handler(e) {
                if (arguments.length > 1) {
                    subscriber.next(Array.prototype.slice.call(arguments));
                }
                else {
                    subscriber.next(e);
                }
            }
            setupSubscription(target, eventName, handler, subscriber, options);
        });
    }
    function setupSubscription(sourceObj, eventName, handler, subscriber, options) {
        var unsubscribe;
        if (isEventTarget(sourceObj)) {
            var source_1 = sourceObj;
            sourceObj.addEventListener(eventName, handler, options);
            unsubscribe = function () { return source_1.removeEventListener(eventName, handler, options); };
        }
        else if (isJQueryStyleEventEmitter(sourceObj)) {
            var source_2 = sourceObj;
            sourceObj.on(eventName, handler);
            unsubscribe = function () { return source_2.off(eventName, handler); };
        }
        else if (isNodeStyleEventEmitter(sourceObj)) {
            var source_3 = sourceObj;
            sourceObj.addListener(eventName, handler);
            unsubscribe = function () { return source_3.removeListener(eventName, handler); };
        }
        else if (sourceObj && sourceObj.length) {
            for (var i = 0, len = sourceObj.length; i < len; i++) {
                setupSubscription(sourceObj[i], eventName, handler, subscriber, options);
            }
        }
        else {
            throw new TypeError('Invalid event target');
        }
        subscriber.add(unsubscribe);
    }
    function isNodeStyleEventEmitter(sourceObj) {
        return sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';
    }
    function isJQueryStyleEventEmitter(sourceObj) {
        return sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';
    }
    function isEventTarget(sourceObj) {
        return sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';
    }

    /** PURE_IMPORTS_START _isArray PURE_IMPORTS_END */
    function isNumeric(val) {
        return !isArray$1(val) && (val - parseFloat(val) + 1) >= 0;
    }

    /** PURE_IMPORTS_START _Observable,_util_isScheduler,_operators_mergeAll,_fromArray PURE_IMPORTS_END */
    function merge() {
        var observables = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            observables[_i] = arguments[_i];
        }
        var concurrent = Number.POSITIVE_INFINITY;
        var scheduler = null;
        var last = observables[observables.length - 1];
        if (isScheduler(last)) {
            scheduler = observables.pop();
            if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') {
                concurrent = observables.pop();
            }
        }
        else if (typeof last === 'number') {
            concurrent = observables.pop();
        }
        if (scheduler === null && observables.length === 1 && observables[0] instanceof Observable) {
            return observables[0];
        }
        return mergeAll(concurrent)(fromArray(observables, scheduler));
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function filter(predicate, thisArg) {
        return function filterOperatorFunction(source) {
            return source.lift(new FilterOperator(predicate, thisArg));
        };
    }
    var FilterOperator = /*@__PURE__*/ (function () {
        function FilterOperator(predicate, thisArg) {
            this.predicate = predicate;
            this.thisArg = thisArg;
        }
        FilterOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
        };
        return FilterOperator;
    }());
    var FilterSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(FilterSubscriber, _super);
        function FilterSubscriber(destination, predicate, thisArg) {
            var _this = _super.call(this, destination) || this;
            _this.predicate = predicate;
            _this.thisArg = thisArg;
            _this.count = 0;
            return _this;
        }
        FilterSubscriber.prototype._next = function (value) {
            var result;
            try {
                result = this.predicate.call(this.thisArg, value, this.count++);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            if (result) {
                this.destination.next(value);
            }
        };
        return FilterSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _Observable,_scheduler_async,_util_isNumeric,_util_isScheduler PURE_IMPORTS_END */
    function timer(dueTime, periodOrScheduler, scheduler) {
        if (dueTime === void 0) {
            dueTime = 0;
        }
        var period = -1;
        if (isNumeric(periodOrScheduler)) {
            period = Number(periodOrScheduler) < 1 && 1 || Number(periodOrScheduler);
        }
        else if (isScheduler(periodOrScheduler)) {
            scheduler = periodOrScheduler;
        }
        if (!isScheduler(scheduler)) {
            scheduler = async;
        }
        return new Observable(function (subscriber) {
            var due = isNumeric(dueTime)
                ? dueTime
                : (+dueTime - scheduler.now());
            return scheduler.schedule(dispatch, due, {
                index: 0, period: period, subscriber: subscriber
            });
        });
    }
    function dispatch(state) {
        var index = state.index, period = state.period, subscriber = state.subscriber;
        subscriber.next(index);
        if (subscriber.closed) {
            return;
        }
        else if (period === -1) {
            return subscriber.complete();
        }
        state.index = index + 1;
        this.schedule(state, period);
    }

    /** PURE_IMPORTS_START tslib,_fromArray,_util_isArray,_Subscriber,_.._internal_symbol_iterator,_innerSubscribe PURE_IMPORTS_END */
    function zip() {
        var observables = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            observables[_i] = arguments[_i];
        }
        var resultSelector = observables[observables.length - 1];
        if (typeof resultSelector === 'function') {
            observables.pop();
        }
        return fromArray(observables, undefined).lift(new ZipOperator(resultSelector));
    }
    var ZipOperator = /*@__PURE__*/ (function () {
        function ZipOperator(resultSelector) {
            this.resultSelector = resultSelector;
        }
        ZipOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new ZipSubscriber(subscriber, this.resultSelector));
        };
        return ZipOperator;
    }());
    var ZipSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(ZipSubscriber, _super);
        function ZipSubscriber(destination, resultSelector, values) {
            var _this = _super.call(this, destination) || this;
            _this.resultSelector = resultSelector;
            _this.iterators = [];
            _this.active = 0;
            _this.resultSelector = (typeof resultSelector === 'function') ? resultSelector : undefined;
            return _this;
        }
        ZipSubscriber.prototype._next = function (value) {
            var iterators = this.iterators;
            if (isArray$1(value)) {
                iterators.push(new StaticArrayIterator(value));
            }
            else if (typeof value[iterator] === 'function') {
                iterators.push(new StaticIterator(value[iterator]()));
            }
            else {
                iterators.push(new ZipBufferIterator(this.destination, this, value));
            }
        };
        ZipSubscriber.prototype._complete = function () {
            var iterators = this.iterators;
            var len = iterators.length;
            this.unsubscribe();
            if (len === 0) {
                this.destination.complete();
                return;
            }
            this.active = len;
            for (var i = 0; i < len; i++) {
                var iterator = iterators[i];
                if (iterator.stillUnsubscribed) {
                    var destination = this.destination;
                    destination.add(iterator.subscribe());
                }
                else {
                    this.active--;
                }
            }
        };
        ZipSubscriber.prototype.notifyInactive = function () {
            this.active--;
            if (this.active === 0) {
                this.destination.complete();
            }
        };
        ZipSubscriber.prototype.checkIterators = function () {
            var iterators = this.iterators;
            var len = iterators.length;
            var destination = this.destination;
            for (var i = 0; i < len; i++) {
                var iterator = iterators[i];
                if (typeof iterator.hasValue === 'function' && !iterator.hasValue()) {
                    return;
                }
            }
            var shouldComplete = false;
            var args = [];
            for (var i = 0; i < len; i++) {
                var iterator = iterators[i];
                var result = iterator.next();
                if (iterator.hasCompleted()) {
                    shouldComplete = true;
                }
                if (result.done) {
                    destination.complete();
                    return;
                }
                args.push(result.value);
            }
            if (this.resultSelector) {
                this._tryresultSelector(args);
            }
            else {
                destination.next(args);
            }
            if (shouldComplete) {
                destination.complete();
            }
        };
        ZipSubscriber.prototype._tryresultSelector = function (args) {
            var result;
            try {
                result = this.resultSelector.apply(this, args);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.destination.next(result);
        };
        return ZipSubscriber;
    }(Subscriber));
    var StaticIterator = /*@__PURE__*/ (function () {
        function StaticIterator(iterator) {
            this.iterator = iterator;
            this.nextResult = iterator.next();
        }
        StaticIterator.prototype.hasValue = function () {
            return true;
        };
        StaticIterator.prototype.next = function () {
            var result = this.nextResult;
            this.nextResult = this.iterator.next();
            return result;
        };
        StaticIterator.prototype.hasCompleted = function () {
            var nextResult = this.nextResult;
            return Boolean(nextResult && nextResult.done);
        };
        return StaticIterator;
    }());
    var StaticArrayIterator = /*@__PURE__*/ (function () {
        function StaticArrayIterator(array) {
            this.array = array;
            this.index = 0;
            this.length = 0;
            this.length = array.length;
        }
        StaticArrayIterator.prototype[iterator] = function () {
            return this;
        };
        StaticArrayIterator.prototype.next = function (value) {
            var i = this.index++;
            var array = this.array;
            return i < this.length ? { value: array[i], done: false } : { value: null, done: true };
        };
        StaticArrayIterator.prototype.hasValue = function () {
            return this.array.length > this.index;
        };
        StaticArrayIterator.prototype.hasCompleted = function () {
            return this.array.length === this.index;
        };
        return StaticArrayIterator;
    }());
    var ZipBufferIterator = /*@__PURE__*/ (function (_super) {
        __extends(ZipBufferIterator, _super);
        function ZipBufferIterator(destination, parent, observable) {
            var _this = _super.call(this, destination) || this;
            _this.parent = parent;
            _this.observable = observable;
            _this.stillUnsubscribed = true;
            _this.buffer = [];
            _this.isComplete = false;
            return _this;
        }
        ZipBufferIterator.prototype[iterator] = function () {
            return this;
        };
        ZipBufferIterator.prototype.next = function () {
            var buffer = this.buffer;
            if (buffer.length === 0 && this.isComplete) {
                return { value: null, done: true };
            }
            else {
                return { value: buffer.shift(), done: false };
            }
        };
        ZipBufferIterator.prototype.hasValue = function () {
            return this.buffer.length > 0;
        };
        ZipBufferIterator.prototype.hasCompleted = function () {
            return this.buffer.length === 0 && this.isComplete;
        };
        ZipBufferIterator.prototype.notifyComplete = function () {
            if (this.buffer.length > 0) {
                this.isComplete = true;
                this.parent.notifyInactive();
            }
            else {
                this.destination.complete();
            }
        };
        ZipBufferIterator.prototype.notifyNext = function (innerValue) {
            this.buffer.push(innerValue);
            this.parent.checkIterators();
        };
        ZipBufferIterator.prototype.subscribe = function () {
            return innerSubscribe(this.observable, new SimpleInnerSubscriber(this));
        };
        return ZipBufferIterator;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START tslib,_innerSubscribe PURE_IMPORTS_END */
    function audit(durationSelector) {
        return function auditOperatorFunction(source) {
            return source.lift(new AuditOperator(durationSelector));
        };
    }
    var AuditOperator = /*@__PURE__*/ (function () {
        function AuditOperator(durationSelector) {
            this.durationSelector = durationSelector;
        }
        AuditOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new AuditSubscriber(subscriber, this.durationSelector));
        };
        return AuditOperator;
    }());
    var AuditSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(AuditSubscriber, _super);
        function AuditSubscriber(destination, durationSelector) {
            var _this = _super.call(this, destination) || this;
            _this.durationSelector = durationSelector;
            _this.hasValue = false;
            return _this;
        }
        AuditSubscriber.prototype._next = function (value) {
            this.value = value;
            this.hasValue = true;
            if (!this.throttled) {
                var duration = void 0;
                try {
                    var durationSelector = this.durationSelector;
                    duration = durationSelector(value);
                }
                catch (err) {
                    return this.destination.error(err);
                }
                var innerSubscription = innerSubscribe(duration, new SimpleInnerSubscriber(this));
                if (!innerSubscription || innerSubscription.closed) {
                    this.clearThrottle();
                }
                else {
                    this.add(this.throttled = innerSubscription);
                }
            }
        };
        AuditSubscriber.prototype.clearThrottle = function () {
            var _a = this, value = _a.value, hasValue = _a.hasValue, throttled = _a.throttled;
            if (throttled) {
                this.remove(throttled);
                this.throttled = undefined;
                throttled.unsubscribe();
            }
            if (hasValue) {
                this.value = undefined;
                this.hasValue = false;
                this.destination.next(value);
            }
        };
        AuditSubscriber.prototype.notifyNext = function () {
            this.clearThrottle();
        };
        AuditSubscriber.prototype.notifyComplete = function () {
            this.clearThrottle();
        };
        return AuditSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START _scheduler_async,_audit,_observable_timer PURE_IMPORTS_END */
    function auditTime(duration, scheduler) {
        if (scheduler === void 0) {
            scheduler = async;
        }
        return audit(function () { return timer(duration, scheduler); });
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function bufferCount(bufferSize, startBufferEvery) {
        if (startBufferEvery === void 0) {
            startBufferEvery = null;
        }
        return function bufferCountOperatorFunction(source) {
            return source.lift(new BufferCountOperator(bufferSize, startBufferEvery));
        };
    }
    var BufferCountOperator = /*@__PURE__*/ (function () {
        function BufferCountOperator(bufferSize, startBufferEvery) {
            this.bufferSize = bufferSize;
            this.startBufferEvery = startBufferEvery;
            if (!startBufferEvery || bufferSize === startBufferEvery) {
                this.subscriberClass = BufferCountSubscriber;
            }
            else {
                this.subscriberClass = BufferSkipCountSubscriber;
            }
        }
        BufferCountOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new this.subscriberClass(subscriber, this.bufferSize, this.startBufferEvery));
        };
        return BufferCountOperator;
    }());
    var BufferCountSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(BufferCountSubscriber, _super);
        function BufferCountSubscriber(destination, bufferSize) {
            var _this = _super.call(this, destination) || this;
            _this.bufferSize = bufferSize;
            _this.buffer = [];
            return _this;
        }
        BufferCountSubscriber.prototype._next = function (value) {
            var buffer = this.buffer;
            buffer.push(value);
            if (buffer.length == this.bufferSize) {
                this.destination.next(buffer);
                this.buffer = [];
            }
        };
        BufferCountSubscriber.prototype._complete = function () {
            var buffer = this.buffer;
            if (buffer.length > 0) {
                this.destination.next(buffer);
            }
            _super.prototype._complete.call(this);
        };
        return BufferCountSubscriber;
    }(Subscriber));
    var BufferSkipCountSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(BufferSkipCountSubscriber, _super);
        function BufferSkipCountSubscriber(destination, bufferSize, startBufferEvery) {
            var _this = _super.call(this, destination) || this;
            _this.bufferSize = bufferSize;
            _this.startBufferEvery = startBufferEvery;
            _this.buffers = [];
            _this.count = 0;
            return _this;
        }
        BufferSkipCountSubscriber.prototype._next = function (value) {
            var _a = this, bufferSize = _a.bufferSize, startBufferEvery = _a.startBufferEvery, buffers = _a.buffers, count = _a.count;
            this.count++;
            if (count % startBufferEvery === 0) {
                buffers.push([]);
            }
            for (var i = buffers.length; i--;) {
                var buffer = buffers[i];
                buffer.push(value);
                if (buffer.length === bufferSize) {
                    buffers.splice(i, 1);
                    this.destination.next(buffer);
                }
            }
        };
        BufferSkipCountSubscriber.prototype._complete = function () {
            var _a = this, buffers = _a.buffers, destination = _a.destination;
            while (buffers.length > 0) {
                var buffer = buffers.shift();
                if (buffer.length > 0) {
                    destination.next(buffer);
                }
            }
            _super.prototype._complete.call(this);
        };
        return BufferSkipCountSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_Subscription,_innerSubscribe PURE_IMPORTS_END */
    function bufferWhen(closingSelector) {
        return function (source) {
            return source.lift(new BufferWhenOperator(closingSelector));
        };
    }
    var BufferWhenOperator = /*@__PURE__*/ (function () {
        function BufferWhenOperator(closingSelector) {
            this.closingSelector = closingSelector;
        }
        BufferWhenOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new BufferWhenSubscriber(subscriber, this.closingSelector));
        };
        return BufferWhenOperator;
    }());
    var BufferWhenSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(BufferWhenSubscriber, _super);
        function BufferWhenSubscriber(destination, closingSelector) {
            var _this = _super.call(this, destination) || this;
            _this.closingSelector = closingSelector;
            _this.subscribing = false;
            _this.openBuffer();
            return _this;
        }
        BufferWhenSubscriber.prototype._next = function (value) {
            this.buffer.push(value);
        };
        BufferWhenSubscriber.prototype._complete = function () {
            var buffer = this.buffer;
            if (buffer) {
                this.destination.next(buffer);
            }
            _super.prototype._complete.call(this);
        };
        BufferWhenSubscriber.prototype._unsubscribe = function () {
            this.buffer = undefined;
            this.subscribing = false;
        };
        BufferWhenSubscriber.prototype.notifyNext = function () {
            this.openBuffer();
        };
        BufferWhenSubscriber.prototype.notifyComplete = function () {
            if (this.subscribing) {
                this.complete();
            }
            else {
                this.openBuffer();
            }
        };
        BufferWhenSubscriber.prototype.openBuffer = function () {
            var closingSubscription = this.closingSubscription;
            if (closingSubscription) {
                this.remove(closingSubscription);
                closingSubscription.unsubscribe();
            }
            var buffer = this.buffer;
            if (this.buffer) {
                this.destination.next(buffer);
            }
            this.buffer = [];
            var closingNotifier;
            try {
                var closingSelector = this.closingSelector;
                closingNotifier = closingSelector();
            }
            catch (err) {
                return this.error(err);
            }
            closingSubscription = new Subscription();
            this.closingSubscription = closingSubscription;
            this.add(closingSubscription);
            this.subscribing = true;
            closingSubscription.add(innerSubscribe(closingNotifier, new SimpleInnerSubscriber(this)));
            this.subscribing = false;
        };
        return BufferWhenSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START tslib,_innerSubscribe PURE_IMPORTS_END */
    function catchError(selector) {
        return function catchErrorOperatorFunction(source) {
            var operator = new CatchOperator(selector);
            var caught = source.lift(operator);
            return (operator.caught = caught);
        };
    }
    var CatchOperator = /*@__PURE__*/ (function () {
        function CatchOperator(selector) {
            this.selector = selector;
        }
        CatchOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new CatchSubscriber(subscriber, this.selector, this.caught));
        };
        return CatchOperator;
    }());
    var CatchSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(CatchSubscriber, _super);
        function CatchSubscriber(destination, selector, caught) {
            var _this = _super.call(this, destination) || this;
            _this.selector = selector;
            _this.caught = caught;
            return _this;
        }
        CatchSubscriber.prototype.error = function (err) {
            if (!this.isStopped) {
                var result = void 0;
                try {
                    result = this.selector(err, this.caught);
                }
                catch (err2) {
                    _super.prototype.error.call(this, err2);
                    return;
                }
                this._unsubscribeAndRecycle();
                var innerSubscriber = new SimpleInnerSubscriber(this);
                this.add(innerSubscriber);
                var innerSubscription = innerSubscribe(result, innerSubscriber);
                if (innerSubscription !== innerSubscriber) {
                    this.add(innerSubscription);
                }
            }
        };
        return CatchSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START _mergeMap PURE_IMPORTS_END */
    function concatMap(project, resultSelector) {
        return mergeMap(project, resultSelector, 1);
    }

    /** PURE_IMPORTS_START tslib,_Subscriber,_scheduler_async PURE_IMPORTS_END */
    function debounceTime(dueTime, scheduler) {
        if (scheduler === void 0) {
            scheduler = async;
        }
        return function (source) { return source.lift(new DebounceTimeOperator(dueTime, scheduler)); };
    }
    var DebounceTimeOperator = /*@__PURE__*/ (function () {
        function DebounceTimeOperator(dueTime, scheduler) {
            this.dueTime = dueTime;
            this.scheduler = scheduler;
        }
        DebounceTimeOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler));
        };
        return DebounceTimeOperator;
    }());
    var DebounceTimeSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(DebounceTimeSubscriber, _super);
        function DebounceTimeSubscriber(destination, dueTime, scheduler) {
            var _this = _super.call(this, destination) || this;
            _this.dueTime = dueTime;
            _this.scheduler = scheduler;
            _this.debouncedSubscription = null;
            _this.lastValue = null;
            _this.hasValue = false;
            return _this;
        }
        DebounceTimeSubscriber.prototype._next = function (value) {
            this.clearDebounce();
            this.lastValue = value;
            this.hasValue = true;
            this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext, this.dueTime, this));
        };
        DebounceTimeSubscriber.prototype._complete = function () {
            this.debouncedNext();
            this.destination.complete();
        };
        DebounceTimeSubscriber.prototype.debouncedNext = function () {
            this.clearDebounce();
            if (this.hasValue) {
                var lastValue = this.lastValue;
                this.lastValue = null;
                this.hasValue = false;
                this.destination.next(lastValue);
            }
        };
        DebounceTimeSubscriber.prototype.clearDebounce = function () {
            var debouncedSubscription = this.debouncedSubscription;
            if (debouncedSubscription !== null) {
                this.remove(debouncedSubscription);
                debouncedSubscription.unsubscribe();
                this.debouncedSubscription = null;
            }
        };
        return DebounceTimeSubscriber;
    }(Subscriber));
    function dispatchNext(subscriber) {
        subscriber.debouncedNext();
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function defaultIfEmpty(defaultValue) {
        if (defaultValue === void 0) {
            defaultValue = null;
        }
        return function (source) { return source.lift(new DefaultIfEmptyOperator(defaultValue)); };
    }
    var DefaultIfEmptyOperator = /*@__PURE__*/ (function () {
        function DefaultIfEmptyOperator(defaultValue) {
            this.defaultValue = defaultValue;
        }
        DefaultIfEmptyOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new DefaultIfEmptySubscriber(subscriber, this.defaultValue));
        };
        return DefaultIfEmptyOperator;
    }());
    var DefaultIfEmptySubscriber = /*@__PURE__*/ (function (_super) {
        __extends(DefaultIfEmptySubscriber, _super);
        function DefaultIfEmptySubscriber(destination, defaultValue) {
            var _this = _super.call(this, destination) || this;
            _this.defaultValue = defaultValue;
            _this.isEmpty = true;
            return _this;
        }
        DefaultIfEmptySubscriber.prototype._next = function (value) {
            this.isEmpty = false;
            this.destination.next(value);
        };
        DefaultIfEmptySubscriber.prototype._complete = function () {
            if (this.isEmpty) {
                this.destination.next(this.defaultValue);
            }
            this.destination.complete();
        };
        return DefaultIfEmptySubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START  PURE_IMPORTS_END */
    function isDate(value) {
        return value instanceof Date && !isNaN(+value);
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function distinctUntilChanged(compare, keySelector) {
        return function (source) { return source.lift(new DistinctUntilChangedOperator(compare, keySelector)); };
    }
    var DistinctUntilChangedOperator = /*@__PURE__*/ (function () {
        function DistinctUntilChangedOperator(compare, keySelector) {
            this.compare = compare;
            this.keySelector = keySelector;
        }
        DistinctUntilChangedOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));
        };
        return DistinctUntilChangedOperator;
    }());
    var DistinctUntilChangedSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(DistinctUntilChangedSubscriber, _super);
        function DistinctUntilChangedSubscriber(destination, compare, keySelector) {
            var _this = _super.call(this, destination) || this;
            _this.keySelector = keySelector;
            _this.hasKey = false;
            if (typeof compare === 'function') {
                _this.compare = compare;
            }
            return _this;
        }
        DistinctUntilChangedSubscriber.prototype.compare = function (x, y) {
            return x === y;
        };
        DistinctUntilChangedSubscriber.prototype._next = function (value) {
            var key;
            try {
                var keySelector = this.keySelector;
                key = keySelector ? keySelector(value) : value;
            }
            catch (err) {
                return this.destination.error(err);
            }
            var result = false;
            if (this.hasKey) {
                try {
                    var compare = this.compare;
                    result = compare(this.key, key);
                }
                catch (err) {
                    return this.destination.error(err);
                }
            }
            else {
                this.hasKey = true;
            }
            if (!result) {
                this.key = key;
                this.destination.next(value);
            }
        };
        return DistinctUntilChangedSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_util_EmptyError,_Subscriber PURE_IMPORTS_END */
    function throwIfEmpty(errorFactory) {
        if (errorFactory === void 0) {
            errorFactory = defaultErrorFactory;
        }
        return function (source) {
            return source.lift(new ThrowIfEmptyOperator(errorFactory));
        };
    }
    var ThrowIfEmptyOperator = /*@__PURE__*/ (function () {
        function ThrowIfEmptyOperator(errorFactory) {
            this.errorFactory = errorFactory;
        }
        ThrowIfEmptyOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new ThrowIfEmptySubscriber(subscriber, this.errorFactory));
        };
        return ThrowIfEmptyOperator;
    }());
    var ThrowIfEmptySubscriber = /*@__PURE__*/ (function (_super) {
        __extends(ThrowIfEmptySubscriber, _super);
        function ThrowIfEmptySubscriber(destination, errorFactory) {
            var _this = _super.call(this, destination) || this;
            _this.errorFactory = errorFactory;
            _this.hasValue = false;
            return _this;
        }
        ThrowIfEmptySubscriber.prototype._next = function (value) {
            this.hasValue = true;
            this.destination.next(value);
        };
        ThrowIfEmptySubscriber.prototype._complete = function () {
            if (!this.hasValue) {
                var err = void 0;
                try {
                    err = this.errorFactory();
                }
                catch (e) {
                    err = e;
                }
                this.destination.error(err);
            }
            else {
                return this.destination.complete();
            }
        };
        return ThrowIfEmptySubscriber;
    }(Subscriber));
    function defaultErrorFactory() {
        return new EmptyError();
    }

    /** PURE_IMPORTS_START tslib,_Subscriber,_util_ArgumentOutOfRangeError,_observable_empty PURE_IMPORTS_END */
    function take(count) {
        return function (source) {
            if (count === 0) {
                return empty();
            }
            else {
                return source.lift(new TakeOperator(count));
            }
        };
    }
    var TakeOperator = /*@__PURE__*/ (function () {
        function TakeOperator(total) {
            this.total = total;
            if (this.total < 0) {
                throw new ArgumentOutOfRangeError;
            }
        }
        TakeOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new TakeSubscriber(subscriber, this.total));
        };
        return TakeOperator;
    }());
    var TakeSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(TakeSubscriber, _super);
        function TakeSubscriber(destination, total) {
            var _this = _super.call(this, destination) || this;
            _this.total = total;
            _this.count = 0;
            return _this;
        }
        TakeSubscriber.prototype._next = function (value) {
            var total = this.total;
            var count = ++this.count;
            if (count <= total) {
                this.destination.next(value);
                if (count === total) {
                    this.destination.complete();
                    this.unsubscribe();
                }
            }
        };
        return TakeSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_innerSubscribe PURE_IMPORTS_END */
    function expand(project, concurrent, scheduler) {
        if (concurrent === void 0) {
            concurrent = Number.POSITIVE_INFINITY;
        }
        concurrent = (concurrent || 0) < 1 ? Number.POSITIVE_INFINITY : concurrent;
        return function (source) { return source.lift(new ExpandOperator(project, concurrent, scheduler)); };
    }
    var ExpandOperator = /*@__PURE__*/ (function () {
        function ExpandOperator(project, concurrent, scheduler) {
            this.project = project;
            this.concurrent = concurrent;
            this.scheduler = scheduler;
        }
        ExpandOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new ExpandSubscriber(subscriber, this.project, this.concurrent, this.scheduler));
        };
        return ExpandOperator;
    }());
    var ExpandSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(ExpandSubscriber, _super);
        function ExpandSubscriber(destination, project, concurrent, scheduler) {
            var _this = _super.call(this, destination) || this;
            _this.project = project;
            _this.concurrent = concurrent;
            _this.scheduler = scheduler;
            _this.index = 0;
            _this.active = 0;
            _this.hasCompleted = false;
            if (concurrent < Number.POSITIVE_INFINITY) {
                _this.buffer = [];
            }
            return _this;
        }
        ExpandSubscriber.dispatch = function (arg) {
            var subscriber = arg.subscriber, result = arg.result, value = arg.value, index = arg.index;
            subscriber.subscribeToProjection(result, value, index);
        };
        ExpandSubscriber.prototype._next = function (value) {
            var destination = this.destination;
            if (destination.closed) {
                this._complete();
                return;
            }
            var index = this.index++;
            if (this.active < this.concurrent) {
                destination.next(value);
                try {
                    var project = this.project;
                    var result = project(value, index);
                    if (!this.scheduler) {
                        this.subscribeToProjection(result, value, index);
                    }
                    else {
                        var state = { subscriber: this, result: result, value: value, index: index };
                        var destination_1 = this.destination;
                        destination_1.add(this.scheduler.schedule(ExpandSubscriber.dispatch, 0, state));
                    }
                }
                catch (e) {
                    destination.error(e);
                }
            }
            else {
                this.buffer.push(value);
            }
        };
        ExpandSubscriber.prototype.subscribeToProjection = function (result, value, index) {
            this.active++;
            var destination = this.destination;
            destination.add(innerSubscribe(result, new SimpleInnerSubscriber(this)));
        };
        ExpandSubscriber.prototype._complete = function () {
            this.hasCompleted = true;
            if (this.hasCompleted && this.active === 0) {
                this.destination.complete();
            }
            this.unsubscribe();
        };
        ExpandSubscriber.prototype.notifyNext = function (innerValue) {
            this._next(innerValue);
        };
        ExpandSubscriber.prototype.notifyComplete = function () {
            var buffer = this.buffer;
            this.active--;
            if (buffer && buffer.length > 0) {
                this._next(buffer.shift());
            }
            if (this.hasCompleted && this.active === 0) {
                this.destination.complete();
            }
        };
        return ExpandSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START tslib,_Subscriber,_Subscription PURE_IMPORTS_END */
    function finalize(callback) {
        return function (source) { return source.lift(new FinallyOperator(callback)); };
    }
    var FinallyOperator = /*@__PURE__*/ (function () {
        function FinallyOperator(callback) {
            this.callback = callback;
        }
        FinallyOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new FinallySubscriber(subscriber, this.callback));
        };
        return FinallyOperator;
    }());
    var FinallySubscriber = /*@__PURE__*/ (function (_super) {
        __extends(FinallySubscriber, _super);
        function FinallySubscriber(destination, callback) {
            var _this = _super.call(this, destination) || this;
            _this.add(new Subscription(callback));
            return _this;
        }
        return FinallySubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _util_EmptyError,_filter,_take,_defaultIfEmpty,_throwIfEmpty,_util_identity PURE_IMPORTS_END */
    function first(predicate, defaultValue) {
        var hasDefaultValue = arguments.length >= 2;
        return function (source) { return source.pipe(predicate ? filter(function (v, i) { return predicate(v, i, source); }) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () { return new EmptyError(); })); };
    }

    /** PURE_IMPORTS_START tslib,_Subscriber,_util_ArgumentOutOfRangeError,_observable_empty PURE_IMPORTS_END */
    function takeLast(count) {
        return function takeLastOperatorFunction(source) {
            if (count === 0) {
                return empty();
            }
            else {
                return source.lift(new TakeLastOperator(count));
            }
        };
    }
    var TakeLastOperator = /*@__PURE__*/ (function () {
        function TakeLastOperator(total) {
            this.total = total;
            if (this.total < 0) {
                throw new ArgumentOutOfRangeError;
            }
        }
        TakeLastOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new TakeLastSubscriber(subscriber, this.total));
        };
        return TakeLastOperator;
    }());
    var TakeLastSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(TakeLastSubscriber, _super);
        function TakeLastSubscriber(destination, total) {
            var _this = _super.call(this, destination) || this;
            _this.total = total;
            _this.ring = new Array();
            _this.count = 0;
            return _this;
        }
        TakeLastSubscriber.prototype._next = function (value) {
            var ring = this.ring;
            var total = this.total;
            var count = this.count++;
            if (ring.length < total) {
                ring.push(value);
            }
            else {
                var index = count % total;
                ring[index] = value;
            }
        };
        TakeLastSubscriber.prototype._complete = function () {
            var destination = this.destination;
            var count = this.count;
            if (count > 0) {
                var total = this.count >= this.total ? this.total : this.count;
                var ring = this.ring;
                for (var i = 0; i < total; i++) {
                    var idx = (count++) % total;
                    destination.next(ring[idx]);
                }
            }
            destination.complete();
        };
        return TakeLastSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _util_EmptyError,_filter,_takeLast,_throwIfEmpty,_defaultIfEmpty,_util_identity PURE_IMPORTS_END */
    function last(predicate, defaultValue) {
        var hasDefaultValue = arguments.length >= 2;
        return function (source) { return source.pipe(predicate ? filter(function (v, i) { return predicate(v, i, source); }) : identity, takeLast(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () { return new EmptyError(); })); };
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function scan(accumulator, seed) {
        var hasSeed = false;
        if (arguments.length >= 2) {
            hasSeed = true;
        }
        return function scanOperatorFunction(source) {
            return source.lift(new ScanOperator(accumulator, seed, hasSeed));
        };
    }
    var ScanOperator = /*@__PURE__*/ (function () {
        function ScanOperator(accumulator, seed, hasSeed) {
            if (hasSeed === void 0) {
                hasSeed = false;
            }
            this.accumulator = accumulator;
            this.seed = seed;
            this.hasSeed = hasSeed;
        }
        ScanOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new ScanSubscriber(subscriber, this.accumulator, this.seed, this.hasSeed));
        };
        return ScanOperator;
    }());
    var ScanSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(ScanSubscriber, _super);
        function ScanSubscriber(destination, accumulator, _seed, hasSeed) {
            var _this = _super.call(this, destination) || this;
            _this.accumulator = accumulator;
            _this._seed = _seed;
            _this.hasSeed = hasSeed;
            _this.index = 0;
            return _this;
        }
        Object.defineProperty(ScanSubscriber.prototype, "seed", {
            get: function () {
                return this._seed;
            },
            set: function (value) {
                this.hasSeed = true;
                this._seed = value;
            },
            enumerable: true,
            configurable: true
        });
        ScanSubscriber.prototype._next = function (value) {
            if (!this.hasSeed) {
                this.seed = value;
                this.destination.next(value);
            }
            else {
                return this._tryNext(value);
            }
        };
        ScanSubscriber.prototype._tryNext = function (value) {
            var index = this.index++;
            var result;
            try {
                result = this.accumulator(this.seed, value, index);
            }
            catch (err) {
                this.destination.error(err);
            }
            this.seed = result;
            this.destination.next(result);
        };
        return ScanSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _scan,_takeLast,_defaultIfEmpty,_util_pipe PURE_IMPORTS_END */
    function reduce(accumulator, seed) {
        if (arguments.length >= 2) {
            return function reduceOperatorFunctionWithSeed(source) {
                return pipe(scan(accumulator, seed), takeLast(1), defaultIfEmpty(seed))(source);
            };
        }
        return function reduceOperatorFunction(source) {
            return pipe(scan(function (acc, value, index) { return accumulator(acc, value, index + 1); }), takeLast(1))(source);
        };
    }

    /** PURE_IMPORTS_START _observable_ConnectableObservable PURE_IMPORTS_END */
    function multicast(subjectOrSubjectFactory, selector) {
        return function multicastOperatorFunction(source) {
            var subjectFactory;
            if (typeof subjectOrSubjectFactory === 'function') {
                subjectFactory = subjectOrSubjectFactory;
            }
            else {
                subjectFactory = function subjectFactory() {
                    return subjectOrSubjectFactory;
                };
            }
            if (typeof selector === 'function') {
                return source.lift(new MulticastOperator(subjectFactory, selector));
            }
            var connectable = Object.create(source, connectableObservableDescriptor);
            connectable.source = source;
            connectable.subjectFactory = subjectFactory;
            return connectable;
        };
    }
    var MulticastOperator = /*@__PURE__*/ (function () {
        function MulticastOperator(subjectFactory, selector) {
            this.subjectFactory = subjectFactory;
            this.selector = selector;
        }
        MulticastOperator.prototype.call = function (subscriber, source) {
            var selector = this.selector;
            var subject = this.subjectFactory();
            var subscription = selector(subject).subscribe(subscriber);
            subscription.add(source.subscribe(subject));
            return subscription;
        };
        return MulticastOperator;
    }());

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function pairwise() {
        return function (source) { return source.lift(new PairwiseOperator()); };
    }
    var PairwiseOperator = /*@__PURE__*/ (function () {
        function PairwiseOperator() {
        }
        PairwiseOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new PairwiseSubscriber(subscriber));
        };
        return PairwiseOperator;
    }());
    var PairwiseSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(PairwiseSubscriber, _super);
        function PairwiseSubscriber(destination) {
            var _this = _super.call(this, destination) || this;
            _this.hasPrev = false;
            return _this;
        }
        PairwiseSubscriber.prototype._next = function (value) {
            var pair;
            if (this.hasPrev) {
                pair = [this.prev, value];
            }
            else {
                this.hasPrev = true;
            }
            this.prev = value;
            if (pair) {
                this.destination.next(pair);
            }
        };
        return PairwiseSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _map PURE_IMPORTS_END */
    function pluck() {
        var properties = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            properties[_i] = arguments[_i];
        }
        var length = properties.length;
        if (length === 0) {
            throw new Error('list of properties cannot be empty.');
        }
        return function (source) { return map(plucker(properties, length))(source); };
    }
    function plucker(props, length) {
        var mapper = function (x) {
            var currentProp = x;
            for (var i = 0; i < length; i++) {
                var p = currentProp != null ? currentProp[props[i]] : undefined;
                if (p !== void 0) {
                    currentProp = p;
                }
                else {
                    return undefined;
                }
            }
            return currentProp;
        };
        return mapper;
    }

    /** PURE_IMPORTS_START _Subject,_multicast PURE_IMPORTS_END */
    function publish(selector) {
        return selector ?
            multicast(function () { return new Subject(); }, selector) :
            multicast(new Subject());
    }

    /** PURE_IMPORTS_START _ReplaySubject,_multicast PURE_IMPORTS_END */
    function publishReplay(bufferSize, windowTime, selectorOrScheduler, scheduler) {
        if (selectorOrScheduler && typeof selectorOrScheduler !== 'function') {
            scheduler = selectorOrScheduler;
        }
        var selector = typeof selectorOrScheduler === 'function' ? selectorOrScheduler : undefined;
        var subject = new ReplaySubject(bufferSize, windowTime, scheduler);
        return function (source) { return multicast(function () { return subject; }, selector)(source); };
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function retry(count) {
        if (count === void 0) {
            count = -1;
        }
        return function (source) { return source.lift(new RetryOperator(count, source)); };
    }
    var RetryOperator = /*@__PURE__*/ (function () {
        function RetryOperator(count, source) {
            this.count = count;
            this.source = source;
        }
        RetryOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new RetrySubscriber(subscriber, this.count, this.source));
        };
        return RetryOperator;
    }());
    var RetrySubscriber = /*@__PURE__*/ (function (_super) {
        __extends(RetrySubscriber, _super);
        function RetrySubscriber(destination, count, source) {
            var _this = _super.call(this, destination) || this;
            _this.count = count;
            _this.source = source;
            return _this;
        }
        RetrySubscriber.prototype.error = function (err) {
            if (!this.isStopped) {
                var _a = this, source = _a.source, count = _a.count;
                if (count === 0) {
                    return _super.prototype.error.call(this, err);
                }
                else if (count > -1) {
                    this.count = count - 1;
                }
                source.subscribe(this._unsubscribeAndRecycle());
            }
        };
        return RetrySubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_innerSubscribe PURE_IMPORTS_END */
    function sample(notifier) {
        return function (source) { return source.lift(new SampleOperator(notifier)); };
    }
    var SampleOperator = /*@__PURE__*/ (function () {
        function SampleOperator(notifier) {
            this.notifier = notifier;
        }
        SampleOperator.prototype.call = function (subscriber, source) {
            var sampleSubscriber = new SampleSubscriber(subscriber);
            var subscription = source.subscribe(sampleSubscriber);
            subscription.add(innerSubscribe(this.notifier, new SimpleInnerSubscriber(sampleSubscriber)));
            return subscription;
        };
        return SampleOperator;
    }());
    var SampleSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SampleSubscriber, _super);
        function SampleSubscriber() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.hasValue = false;
            return _this;
        }
        SampleSubscriber.prototype._next = function (value) {
            this.value = value;
            this.hasValue = true;
        };
        SampleSubscriber.prototype.notifyNext = function () {
            this.emitValue();
        };
        SampleSubscriber.prototype.notifyComplete = function () {
            this.emitValue();
        };
        SampleSubscriber.prototype.emitValue = function () {
            if (this.hasValue) {
                this.hasValue = false;
                this.destination.next(this.value);
            }
        };
        return SampleSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START _multicast,_refCount,_Subject PURE_IMPORTS_END */
    function shareSubjectFactory() {
        return new Subject();
    }
    function share() {
        return function (source) { return refCount()(multicast(shareSubjectFactory)(source)); };
    }

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function skip(count) {
        return function (source) { return source.lift(new SkipOperator(count)); };
    }
    var SkipOperator = /*@__PURE__*/ (function () {
        function SkipOperator(total) {
            this.total = total;
        }
        SkipOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new SkipSubscriber(subscriber, this.total));
        };
        return SkipOperator;
    }());
    var SkipSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SkipSubscriber, _super);
        function SkipSubscriber(destination, total) {
            var _this = _super.call(this, destination) || this;
            _this.total = total;
            _this.count = 0;
            return _this;
        }
        SkipSubscriber.prototype._next = function (x) {
            if (++this.count > this.total) {
                this.destination.next(x);
            }
        };
        return SkipSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function skipWhile(predicate) {
        return function (source) { return source.lift(new SkipWhileOperator(predicate)); };
    }
    var SkipWhileOperator = /*@__PURE__*/ (function () {
        function SkipWhileOperator(predicate) {
            this.predicate = predicate;
        }
        SkipWhileOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new SkipWhileSubscriber(subscriber, this.predicate));
        };
        return SkipWhileOperator;
    }());
    var SkipWhileSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SkipWhileSubscriber, _super);
        function SkipWhileSubscriber(destination, predicate) {
            var _this = _super.call(this, destination) || this;
            _this.predicate = predicate;
            _this.skipping = true;
            _this.index = 0;
            return _this;
        }
        SkipWhileSubscriber.prototype._next = function (value) {
            var destination = this.destination;
            if (this.skipping) {
                this.tryCallPredicate(value);
            }
            if (!this.skipping) {
                destination.next(value);
            }
        };
        SkipWhileSubscriber.prototype.tryCallPredicate = function (value) {
            try {
                var result = this.predicate(value, this.index++);
                this.skipping = Boolean(result);
            }
            catch (err) {
                this.destination.error(err);
            }
        };
        return SkipWhileSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START _observable_concat,_util_isScheduler PURE_IMPORTS_END */
    function startWith() {
        var array = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            array[_i] = arguments[_i];
        }
        var scheduler = array[array.length - 1];
        if (isScheduler(scheduler)) {
            array.pop();
            return function (source) { return concat(array, source, scheduler); };
        }
        else {
            return function (source) { return concat(array, source); };
        }
    }

    /** PURE_IMPORTS_START tslib,_map,_observable_from,_innerSubscribe PURE_IMPORTS_END */
    function switchMap(project, resultSelector) {
        if (typeof resultSelector === 'function') {
            return function (source) { return source.pipe(switchMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); })); };
        }
        return function (source) { return source.lift(new SwitchMapOperator(project)); };
    }
    var SwitchMapOperator = /*@__PURE__*/ (function () {
        function SwitchMapOperator(project) {
            this.project = project;
        }
        SwitchMapOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new SwitchMapSubscriber(subscriber, this.project));
        };
        return SwitchMapOperator;
    }());
    var SwitchMapSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(SwitchMapSubscriber, _super);
        function SwitchMapSubscriber(destination, project) {
            var _this = _super.call(this, destination) || this;
            _this.project = project;
            _this.index = 0;
            return _this;
        }
        SwitchMapSubscriber.prototype._next = function (value) {
            var result;
            var index = this.index++;
            try {
                result = this.project(value, index);
            }
            catch (error) {
                this.destination.error(error);
                return;
            }
            this._innerSub(result);
        };
        SwitchMapSubscriber.prototype._innerSub = function (result) {
            var innerSubscription = this.innerSubscription;
            if (innerSubscription) {
                innerSubscription.unsubscribe();
            }
            var innerSubscriber = new SimpleInnerSubscriber(this);
            var destination = this.destination;
            destination.add(innerSubscriber);
            this.innerSubscription = innerSubscribe(result, innerSubscriber);
            if (this.innerSubscription !== innerSubscriber) {
                destination.add(this.innerSubscription);
            }
        };
        SwitchMapSubscriber.prototype._complete = function () {
            var innerSubscription = this.innerSubscription;
            if (!innerSubscription || innerSubscription.closed) {
                _super.prototype._complete.call(this);
            }
            this.unsubscribe();
        };
        SwitchMapSubscriber.prototype._unsubscribe = function () {
            this.innerSubscription = undefined;
        };
        SwitchMapSubscriber.prototype.notifyComplete = function () {
            this.innerSubscription = undefined;
            if (this.isStopped) {
                _super.prototype._complete.call(this);
            }
        };
        SwitchMapSubscriber.prototype.notifyNext = function (innerValue) {
            this.destination.next(innerValue);
        };
        return SwitchMapSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START tslib,_innerSubscribe PURE_IMPORTS_END */
    function takeUntil(notifier) {
        return function (source) { return source.lift(new TakeUntilOperator(notifier)); };
    }
    var TakeUntilOperator = /*@__PURE__*/ (function () {
        function TakeUntilOperator(notifier) {
            this.notifier = notifier;
        }
        TakeUntilOperator.prototype.call = function (subscriber, source) {
            var takeUntilSubscriber = new TakeUntilSubscriber(subscriber);
            var notifierSubscription = innerSubscribe(this.notifier, new SimpleInnerSubscriber(takeUntilSubscriber));
            if (notifierSubscription && !takeUntilSubscriber.seenValue) {
                takeUntilSubscriber.add(notifierSubscription);
                return source.subscribe(takeUntilSubscriber);
            }
            return takeUntilSubscriber;
        };
        return TakeUntilOperator;
    }());
    var TakeUntilSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(TakeUntilSubscriber, _super);
        function TakeUntilSubscriber(destination) {
            var _this = _super.call(this, destination) || this;
            _this.seenValue = false;
            return _this;
        }
        TakeUntilSubscriber.prototype.notifyNext = function () {
            this.seenValue = true;
            this.complete();
        };
        TakeUntilSubscriber.prototype.notifyComplete = function () {
        };
        return TakeUntilSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */
    function takeWhile(predicate, inclusive) {
        if (inclusive === void 0) {
            inclusive = false;
        }
        return function (source) {
            return source.lift(new TakeWhileOperator(predicate, inclusive));
        };
    }
    var TakeWhileOperator = /*@__PURE__*/ (function () {
        function TakeWhileOperator(predicate, inclusive) {
            this.predicate = predicate;
            this.inclusive = inclusive;
        }
        TakeWhileOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new TakeWhileSubscriber(subscriber, this.predicate, this.inclusive));
        };
        return TakeWhileOperator;
    }());
    var TakeWhileSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(TakeWhileSubscriber, _super);
        function TakeWhileSubscriber(destination, predicate, inclusive) {
            var _this = _super.call(this, destination) || this;
            _this.predicate = predicate;
            _this.inclusive = inclusive;
            _this.index = 0;
            return _this;
        }
        TakeWhileSubscriber.prototype._next = function (value) {
            var destination = this.destination;
            var result;
            try {
                result = this.predicate(value, this.index++);
            }
            catch (err) {
                destination.error(err);
                return;
            }
            this.nextOrComplete(value, result);
        };
        TakeWhileSubscriber.prototype.nextOrComplete = function (value, predicateResult) {
            var destination = this.destination;
            if (Boolean(predicateResult)) {
                destination.next(value);
            }
            else {
                if (this.inclusive) {
                    destination.next(value);
                }
                destination.complete();
            }
        };
        return TakeWhileSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_Subscriber,_util_noop,_util_isFunction PURE_IMPORTS_END */
    function tap(nextOrObserver, error, complete) {
        return function tapOperatorFunction(source) {
            return source.lift(new DoOperator(nextOrObserver, error, complete));
        };
    }
    var DoOperator = /*@__PURE__*/ (function () {
        function DoOperator(nextOrObserver, error, complete) {
            this.nextOrObserver = nextOrObserver;
            this.error = error;
            this.complete = complete;
        }
        DoOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new TapSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));
        };
        return DoOperator;
    }());
    var TapSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(TapSubscriber, _super);
        function TapSubscriber(destination, observerOrNext, error, complete) {
            var _this = _super.call(this, destination) || this;
            _this._tapNext = noop;
            _this._tapError = noop;
            _this._tapComplete = noop;
            _this._tapError = error || noop;
            _this._tapComplete = complete || noop;
            if (isFunction(observerOrNext)) {
                _this._context = _this;
                _this._tapNext = observerOrNext;
            }
            else if (observerOrNext) {
                _this._context = observerOrNext;
                _this._tapNext = observerOrNext.next || noop;
                _this._tapError = observerOrNext.error || noop;
                _this._tapComplete = observerOrNext.complete || noop;
            }
            return _this;
        }
        TapSubscriber.prototype._next = function (value) {
            try {
                this._tapNext.call(this._context, value);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.destination.next(value);
        };
        TapSubscriber.prototype._error = function (err) {
            try {
                this._tapError.call(this._context, err);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.destination.error(err);
        };
        TapSubscriber.prototype._complete = function () {
            try {
                this._tapComplete.call(this._context);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            return this.destination.complete();
        };
        return TapSubscriber;
    }(Subscriber));

    /** PURE_IMPORTS_START tslib,_scheduler_async,_util_isDate,_innerSubscribe PURE_IMPORTS_END */
    function timeoutWith(due, withObservable, scheduler) {
        if (scheduler === void 0) {
            scheduler = async;
        }
        return function (source) {
            var absoluteTimeout = isDate(due);
            var waitFor = absoluteTimeout ? (+due - scheduler.now()) : Math.abs(due);
            return source.lift(new TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler));
        };
    }
    var TimeoutWithOperator = /*@__PURE__*/ (function () {
        function TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler) {
            this.waitFor = waitFor;
            this.absoluteTimeout = absoluteTimeout;
            this.withObservable = withObservable;
            this.scheduler = scheduler;
        }
        TimeoutWithOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new TimeoutWithSubscriber(subscriber, this.absoluteTimeout, this.waitFor, this.withObservable, this.scheduler));
        };
        return TimeoutWithOperator;
    }());
    var TimeoutWithSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(TimeoutWithSubscriber, _super);
        function TimeoutWithSubscriber(destination, absoluteTimeout, waitFor, withObservable, scheduler) {
            var _this = _super.call(this, destination) || this;
            _this.absoluteTimeout = absoluteTimeout;
            _this.waitFor = waitFor;
            _this.withObservable = withObservable;
            _this.scheduler = scheduler;
            _this.scheduleTimeout();
            return _this;
        }
        TimeoutWithSubscriber.dispatchTimeout = function (subscriber) {
            var withObservable = subscriber.withObservable;
            subscriber._unsubscribeAndRecycle();
            subscriber.add(innerSubscribe(withObservable, new SimpleInnerSubscriber(subscriber)));
        };
        TimeoutWithSubscriber.prototype.scheduleTimeout = function () {
            var action = this.action;
            if (action) {
                this.action = action.schedule(this, this.waitFor);
            }
            else {
                this.add(this.action = this.scheduler.schedule(TimeoutWithSubscriber.dispatchTimeout, this.waitFor, this));
            }
        };
        TimeoutWithSubscriber.prototype._next = function (value) {
            if (!this.absoluteTimeout) {
                this.scheduleTimeout();
            }
            _super.prototype._next.call(this, value);
        };
        TimeoutWithSubscriber.prototype._unsubscribe = function () {
            this.action = undefined;
            this.scheduler = null;
            this.withObservable = null;
        };
        return TimeoutWithSubscriber;
    }(SimpleOuterSubscriber));

    /** PURE_IMPORTS_START _scheduler_async,_util_TimeoutError,_timeoutWith,_observable_throwError PURE_IMPORTS_END */
    function timeout(due, scheduler) {
        if (scheduler === void 0) {
            scheduler = async;
        }
        return timeoutWith(due, throwError(new TimeoutError()), scheduler);
    }

    /** PURE_IMPORTS_START tslib,_OuterSubscriber,_util_subscribeToResult PURE_IMPORTS_END */
    function withLatestFrom() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        return function (source) {
            var project;
            if (typeof args[args.length - 1] === 'function') {
                project = args.pop();
            }
            var observables = args;
            return source.lift(new WithLatestFromOperator(observables, project));
        };
    }
    var WithLatestFromOperator = /*@__PURE__*/ (function () {
        function WithLatestFromOperator(observables, project) {
            this.observables = observables;
            this.project = project;
        }
        WithLatestFromOperator.prototype.call = function (subscriber, source) {
            return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));
        };
        return WithLatestFromOperator;
    }());
    var WithLatestFromSubscriber = /*@__PURE__*/ (function (_super) {
        __extends(WithLatestFromSubscriber, _super);
        function WithLatestFromSubscriber(destination, observables, project) {
            var _this = _super.call(this, destination) || this;
            _this.observables = observables;
            _this.project = project;
            _this.toRespond = [];
            var len = observables.length;
            _this.values = new Array(len);
            for (var i = 0; i < len; i++) {
                _this.toRespond.push(i);
            }
            for (var i = 0; i < len; i++) {
                var observable = observables[i];
                _this.add(subscribeToResult(_this, observable, undefined, i));
            }
            return _this;
        }
        WithLatestFromSubscriber.prototype.notifyNext = function (_outerValue, innerValue, outerIndex) {
            this.values[outerIndex] = innerValue;
            var toRespond = this.toRespond;
            if (toRespond.length > 0) {
                var found = toRespond.indexOf(outerIndex);
                if (found !== -1) {
                    toRespond.splice(found, 1);
                }
            }
        };
        WithLatestFromSubscriber.prototype.notifyComplete = function () {
        };
        WithLatestFromSubscriber.prototype._next = function (value) {
            if (this.toRespond.length === 0) {
                var args = [value].concat(this.values);
                if (this.project) {
                    this._tryProject(args);
                }
                else {
                    this.destination.next(args);
                }
            }
        };
        WithLatestFromSubscriber.prototype._tryProject = function (args) {
            var result;
            try {
                result = this.project.apply(this, args);
            }
            catch (err) {
                this.destination.error(err);
                return;
            }
            this.destination.next(result);
        };
        return WithLatestFromSubscriber;
    }(OuterSubscriber));

    /**
     * @class Filter
     *
     * @classdesc Represents a class for creating image filters. Implementation and
     * definitions based on https://github.com/mapbox/feature-filter.
     */
    class FilterCreator {
        /**
         * Create a filter from a filter expression.
         *
         * @description The following filters are supported:
         *
         * Comparison
         * `==`
         * `!=`
         * `<`
         * `<=`
         * `>`
         * `>=`
         *
         * Set membership
         * `in`
         * `!in`
         *
         * Combining
         * `all`
         *
         * @param {FilterExpression} filter - Comparison, set membership or combinding filter
         * expression.
         * @returns {FilterFunction} Function taking a image and returning a boolean that
         * indicates whether the image passed the test or not.
         */
        createFilter(filter) {
            return new Function("node", "return " + this._compile(filter) + ";");
        }
        _compile(filter) {
            if (filter == null || filter.length <= 1) {
                return "true";
            }
            const operator = filter[0];
            const operation = operator === "==" ? this._compileComparisonOp("===", filter[1], filter[2], false) :
                operator === "!=" ? this._compileComparisonOp("!==", filter[1], filter[2], false) :
                    operator === ">" ||
                        operator === ">=" ||
                        operator === "<" ||
                        operator === "<=" ? this._compileComparisonOp(operator, filter[1], filter[2], true) :
                        operator === "in" ?
                            this._compileInOp(filter[1], filter.slice(2)) :
                            operator === "!in" ?
                                this._compileNegation(this._compileInOp(filter[1], filter.slice(2))) :
                                operator === "all" ? this._compileLogicalOp(filter.slice(1), "&&") :
                                    "true";
            return "(" + operation + ")";
        }
        _compare(a, b) {
            return a < b ? -1 : a > b ? 1 : 0;
        }
        _compileComparisonOp(operator, property, value, checkType) {
            const left = this._compilePropertyReference(property);
            const right = JSON.stringify(value);
            return (checkType ? "typeof " + left + "===typeof " + right + "&&" : "") + left + operator + right;
        }
        _compileInOp(property, values) {
            const compare = this._compare;
            const left = JSON.stringify(values.sort(compare));
            const right = this._compilePropertyReference(property);
            return left + ".indexOf(" + right + ")!==-1";
        }
        _compileLogicalOp(filters, operator) {
            const compile = this._compile.bind(this);
            return filters.map(compile).join(operator);
        }
        _compileNegation(expression) {
            return "!(" + expression + ")";
        }
        _compilePropertyReference(property) {
            return "node[" + JSON.stringify(property) + "]";
        }
    }

    // threejs.org/license
    const REVISION = '125';
    const CullFaceNone = 0;
    const CullFaceBack = 1;
    const CullFaceFront = 2;
    const PCFShadowMap = 1;
    const PCFSoftShadowMap = 2;
    const VSMShadowMap = 3;
    const FrontSide = 0;
    const BackSide = 1;
    const DoubleSide = 2;
    const FlatShading = 1;
    const NoBlending = 0;
    const NormalBlending = 1;
    const AdditiveBlending = 2;
    const SubtractiveBlending = 3;
    const MultiplyBlending = 4;
    const CustomBlending = 5;
    const AddEquation = 100;
    const SubtractEquation = 101;
    const ReverseSubtractEquation = 102;
    const MinEquation = 103;
    const MaxEquation = 104;
    const ZeroFactor = 200;
    const OneFactor = 201;
    const SrcColorFactor = 202;
    const OneMinusSrcColorFactor = 203;
    const SrcAlphaFactor = 204;
    const OneMinusSrcAlphaFactor = 205;
    const DstAlphaFactor = 206;
    const OneMinusDstAlphaFactor = 207;
    const DstColorFactor = 208;
    const OneMinusDstColorFactor = 209;
    const SrcAlphaSaturateFactor = 210;
    const NeverDepth = 0;
    const AlwaysDepth = 1;
    const LessDepth = 2;
    const LessEqualDepth = 3;
    const EqualDepth = 4;
    const GreaterEqualDepth = 5;
    const GreaterDepth = 6;
    const NotEqualDepth = 7;
    const MultiplyOperation = 0;
    const MixOperation = 1;
    const AddOperation = 2;
    const NoToneMapping = 0;
    const LinearToneMapping = 1;
    const ReinhardToneMapping = 2;
    const CineonToneMapping = 3;
    const ACESFilmicToneMapping = 4;
    const CustomToneMapping = 5;

    const UVMapping = 300;
    const CubeReflectionMapping = 301;
    const CubeRefractionMapping = 302;
    const EquirectangularReflectionMapping = 303;
    const EquirectangularRefractionMapping = 304;
    const CubeUVReflectionMapping = 306;
    const CubeUVRefractionMapping = 307;
    const RepeatWrapping = 1000;
    const ClampToEdgeWrapping = 1001;
    const MirroredRepeatWrapping = 1002;
    const NearestFilter = 1003;
    const NearestMipmapNearestFilter = 1004;
    const NearestMipmapLinearFilter = 1005;
    const LinearFilter = 1006;
    const LinearMipmapNearestFilter = 1007;
    const LinearMipmapLinearFilter = 1008;
    const UnsignedByteType = 1009;
    const ByteType = 1010;
    const ShortType = 1011;
    const UnsignedShortType = 1012;
    const IntType = 1013;
    const UnsignedIntType = 1014;
    const FloatType = 1015;
    const HalfFloatType = 1016;
    const UnsignedShort4444Type = 1017;
    const UnsignedShort5551Type = 1018;
    const UnsignedShort565Type = 1019;
    const UnsignedInt248Type = 1020;
    const AlphaFormat = 1021;
    const RGBFormat = 1022;
    const RGBAFormat = 1023;
    const LuminanceFormat = 1024;
    const LuminanceAlphaFormat = 1025;
    const DepthFormat = 1026;
    const DepthStencilFormat = 1027;
    const RedFormat = 1028;
    const RedIntegerFormat = 1029;
    const RGFormat = 1030;
    const RGIntegerFormat = 1031;
    const RGBIntegerFormat = 1032;
    const RGBAIntegerFormat = 1033;

    const RGB_S3TC_DXT1_Format = 33776;
    const RGBA_S3TC_DXT1_Format = 33777;
    const RGBA_S3TC_DXT3_Format = 33778;
    const RGBA_S3TC_DXT5_Format = 33779;
    const RGB_PVRTC_4BPPV1_Format = 35840;
    const RGB_PVRTC_2BPPV1_Format = 35841;
    const RGBA_PVRTC_4BPPV1_Format = 35842;
    const RGBA_PVRTC_2BPPV1_Format = 35843;
    const RGB_ETC1_Format = 36196;
    const RGB_ETC2_Format = 37492;
    const RGBA_ETC2_EAC_Format = 37496;
    const RGBA_ASTC_4x4_Format = 37808;
    const RGBA_ASTC_5x4_Format = 37809;
    const RGBA_ASTC_5x5_Format = 37810;
    const RGBA_ASTC_6x5_Format = 37811;
    const RGBA_ASTC_6x6_Format = 37812;
    const RGBA_ASTC_8x5_Format = 37813;
    const RGBA_ASTC_8x6_Format = 37814;
    const RGBA_ASTC_8x8_Format = 37815;
    const RGBA_ASTC_10x5_Format = 37816;
    const RGBA_ASTC_10x6_Format = 37817;
    const RGBA_ASTC_10x8_Format = 37818;
    const RGBA_ASTC_10x10_Format = 37819;
    const RGBA_ASTC_12x10_Format = 37820;
    const RGBA_ASTC_12x12_Format = 37821;
    const RGBA_BPTC_Format = 36492;
    const SRGB8_ALPHA8_ASTC_4x4_Format = 37840;
    const SRGB8_ALPHA8_ASTC_5x4_Format = 37841;
    const SRGB8_ALPHA8_ASTC_5x5_Format = 37842;
    const SRGB8_ALPHA8_ASTC_6x5_Format = 37843;
    const SRGB8_ALPHA8_ASTC_6x6_Format = 37844;
    const SRGB8_ALPHA8_ASTC_8x5_Format = 37845;
    const SRGB8_ALPHA8_ASTC_8x6_Format = 37846;
    const SRGB8_ALPHA8_ASTC_8x8_Format = 37847;
    const SRGB8_ALPHA8_ASTC_10x5_Format = 37848;
    const SRGB8_ALPHA8_ASTC_10x6_Format = 37849;
    const SRGB8_ALPHA8_ASTC_10x8_Format = 37850;
    const SRGB8_ALPHA8_ASTC_10x10_Format = 37851;
    const SRGB8_ALPHA8_ASTC_12x10_Format = 37852;
    const SRGB8_ALPHA8_ASTC_12x12_Format = 37853;
    const LoopOnce = 2200;
    const LoopRepeat = 2201;
    const LoopPingPong = 2202;
    const InterpolateDiscrete = 2300;
    const InterpolateLinear = 2301;
    const InterpolateSmooth = 2302;
    const ZeroCurvatureEnding = 2400;
    const ZeroSlopeEnding = 2401;
    const WrapAroundEnding = 2402;
    const NormalAnimationBlendMode = 2500;
    const AdditiveAnimationBlendMode = 2501;
    const TrianglesDrawMode = 0;
    const LinearEncoding = 3000;
    const sRGBEncoding = 3001;
    const GammaEncoding = 3007;
    const RGBEEncoding = 3002;
    const LogLuvEncoding = 3003;
    const RGBM7Encoding = 3004;
    const RGBM16Encoding = 3005;
    const RGBDEncoding = 3006;
    const BasicDepthPacking = 3200;
    const RGBADepthPacking = 3201;
    const TangentSpaceNormalMap = 0;
    const ObjectSpaceNormalMap = 1;
    const KeepStencilOp = 7680;
    const AlwaysStencilFunc = 519;

    const StaticDrawUsage = 35044;
    const DynamicDrawUsage = 35048;
    const GLSL3 = '300 es';

    /**
     * https://github.com/mrdoob/eventdispatcher.js/
     */

    function EventDispatcher() {}

    Object.assign( EventDispatcher.prototype, {

        addEventListener: function ( type, listener ) {

                if ( this._listeners === undefined ) this._listeners = {};

                const listeners = this._listeners;

                if ( listeners[ type ] === undefined ) {

                        listeners[ type ] = [];

                }

                if ( listeners[ type ].indexOf( listener ) === - 1 ) {

                        listeners[ type ].push( listener );

                }

        },

        hasEventListener: function ( type, listener ) {

                if ( this._listeners === undefined ) return false;

                const listeners = this._listeners;

                return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;

        },

        removeEventListener: function ( type, listener ) {

                if ( this._listeners === undefined ) return;

                const listeners = this._listeners;
                const listenerArray = listeners[ type ];

                if ( listenerArray !== undefined ) {

                        const index = listenerArray.indexOf( listener );

                        if ( index !== - 1 ) {

                                listenerArray.splice( index, 1 );

                        }

                }

        },

        dispatchEvent: function ( event ) {

                if ( this._listeners === undefined ) return;

                const listeners = this._listeners;
                const listenerArray = listeners[ event.type ];

                if ( listenerArray !== undefined ) {

                        event.target = this;

                        // Make a copy, in case listeners are removed while iterating.
                        const array = listenerArray.slice( 0 );

                        for ( let i = 0, l = array.length; i < l; i ++ ) {

                                array[ i ].call( this, event );

                        }

                }

        }

    } );

    const _lut = [];

    for ( let i = 0; i < 256; i ++ ) {

        _lut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 );

    }

    let _seed = 1234567;

    const MathUtils = {

        DEG2RAD: Math.PI / 180,
        RAD2DEG: 180 / Math.PI,

        generateUUID: function () {

                // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136

                const d0 = Math.random() * 0xffffffff | 0;
                const d1 = Math.random() * 0xffffffff | 0;
                const d2 = Math.random() * 0xffffffff | 0;
                const d3 = Math.random() * 0xffffffff | 0;
                const uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
                        _lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
                        _lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
                        _lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];

                // .toUpperCase() here flattens concatenated strings to save heap memory space.
                return uuid.toUpperCase();

        },

        clamp: function ( value, min, max ) {

                return Math.max( min, Math.min( max, value ) );

        },

        // compute euclidian modulo of m % n
        // https://en.wikipedia.org/wiki/Modulo_operation

        euclideanModulo: function ( n, m ) {

                return ( ( n % m ) + m ) % m;

        },

        // Linear mapping from range <a1, a2> to range <b1, b2>

        mapLinear: function ( x, a1, a2, b1, b2 ) {

                return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );

        },

        // https://en.wikipedia.org/wiki/Linear_interpolation

        lerp: function ( x, y, t ) {

                return ( 1 - t ) * x + t * y;

        },

        // http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/

        damp: function ( x, y, lambda, dt ) {

                return MathUtils.lerp( x, y, 1 - Math.exp( - lambda * dt ) );

        },

        // https://www.desmos.com/calculator/vcsjnyz7x4

        pingpong: function ( x, length = 1 ) {

                return length - Math.abs( MathUtils.euclideanModulo( x, length * 2 ) - length );

        },

        // http://en.wikipedia.org/wiki/Smoothstep

        smoothstep: function ( x, min, max ) {

                if ( x <= min ) return 0;
                if ( x >= max ) return 1;

                x = ( x - min ) / ( max - min );

                return x * x * ( 3 - 2 * x );

        },

        smootherstep: function ( x, min, max ) {

                if ( x <= min ) return 0;
                if ( x >= max ) return 1;

                x = ( x - min ) / ( max - min );

                return x * x * x * ( x * ( x * 6 - 15 ) + 10 );

        },

        // Random integer from <low, high> interval

        randInt: function ( low, high ) {

                return low + Math.floor( Math.random() * ( high - low + 1 ) );

        },

        // Random float from <low, high> interval

        randFloat: function ( low, high ) {

                return low + Math.random() * ( high - low );

        },

        // Random float from <-range/2, range/2> interval

        randFloatSpread: function ( range ) {

                return range * ( 0.5 - Math.random() );

        },

        // Deterministic pseudo-random float in the interval [ 0, 1 ]

        seededRandom: function ( s ) {

                if ( s !== undefined ) _seed = s % 2147483647;

                // Park-Miller algorithm

                _seed = _seed * 16807 % 2147483647;

                return ( _seed - 1 ) / 2147483646;

        },

        degToRad: function ( degrees ) {

                return degrees * MathUtils.DEG2RAD;

        },

        radToDeg: function ( radians ) {

                return radians * MathUtils.RAD2DEG;

        },

        isPowerOfTwo: function ( value ) {

                return ( value & ( value - 1 ) ) === 0 && value !== 0;

        },

        ceilPowerOfTwo: function ( value ) {

                return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );

        },

        floorPowerOfTwo: function ( value ) {

                return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );

        },

        setQuaternionFromProperEuler: function ( q, a, b, c, order ) {

                // Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles

                // rotations are applied to the axes in the order specified by 'order'
                // rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
                // angles are in radians

                const cos = Math.cos;
                const sin = Math.sin;

                const c2 = cos( b / 2 );
                const s2 = sin( b / 2 );

                const c13 = cos( ( a + c ) / 2 );
                const s13 = sin( ( a + c ) / 2 );

                const c1_3 = cos( ( a - c ) / 2 );
                const s1_3 = sin( ( a - c ) / 2 );

                const c3_1 = cos( ( c - a ) / 2 );
                const s3_1 = sin( ( c - a ) / 2 );

                switch ( order ) {

                        case 'XYX':
                                q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
                                break;

                        case 'YZY':
                                q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
                                break;

                        case 'ZXZ':
                                q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
                                break;

                        case 'XZX':
                                q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
                                break;

                        case 'YXY':
                                q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
                                break;

                        case 'ZYZ':
                                q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
                                break;

                        default:
                                console.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );

                }

        }

    };

    class Vector2 {

        constructor( x = 0, y = 0 ) {

                Object.defineProperty( this, 'isVector2', { value: true } );

                this.x = x;
                this.y = y;

        }

        get width() {

                return this.x;

        }

        set width( value ) {

                this.x = value;

        }

        get height() {

                return this.y;

        }

        set height( value ) {

                this.y = value;

        }

        set( x, y ) {

                this.x = x;
                this.y = y;

                return this;

        }

        setScalar( scalar ) {

                this.x = scalar;
                this.y = scalar;

                return this;

        }

        setX( x ) {

                this.x = x;

                return this;

        }

        setY( y ) {

                this.y = y;

                return this;

        }

        setComponent( index, value ) {

                switch ( index ) {

                        case 0: this.x = value; break;
                        case 1: this.y = value; break;
                        default: throw new Error( 'index is out of range: ' + index );

                }

                return this;

        }

        getComponent( index ) {

                switch ( index ) {

                        case 0: return this.x;
                        case 1: return this.y;
                        default: throw new Error( 'index is out of range: ' + index );

                }

        }

        clone() {

                return new this.constructor( this.x, this.y );

        }

        copy( v ) {

                this.x = v.x;
                this.y = v.y;

                return this;

        }

        add( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
                        return this.addVectors( v, w );

                }

                this.x += v.x;
                this.y += v.y;

                return this;

        }

        addScalar( s ) {

                this.x += s;
                this.y += s;

                return this;

        }

        addVectors( a, b ) {

                this.x = a.x + b.x;
                this.y = a.y + b.y;

                return this;

        }

        addScaledVector( v, s ) {

                this.x += v.x * s;
                this.y += v.y * s;

                return this;

        }

        sub( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
                        return this.subVectors( v, w );

                }

                this.x -= v.x;
                this.y -= v.y;

                return this;

        }

        subScalar( s ) {

                this.x -= s;
                this.y -= s;

                return this;

        }

        subVectors( a, b ) {

                this.x = a.x - b.x;
                this.y = a.y - b.y;

                return this;

        }

        multiply( v ) {

                this.x *= v.x;
                this.y *= v.y;

                return this;

        }

        multiplyScalar( scalar ) {

                this.x *= scalar;
                this.y *= scalar;

                return this;

        }

        divide( v ) {

                this.x /= v.x;
                this.y /= v.y;

                return this;

        }

        divideScalar( scalar ) {

                return this.multiplyScalar( 1 / scalar );

        }

        applyMatrix3( m ) {

                const x = this.x, y = this.y;
                const e = m.elements;

                this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
                this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];

                return this;

        }

        min( v ) {

                this.x = Math.min( this.x, v.x );
                this.y = Math.min( this.y, v.y );

                return this;

        }

        max( v ) {

                this.x = Math.max( this.x, v.x );
                this.y = Math.max( this.y, v.y );

                return this;

        }

        clamp( min, max ) {

                // assumes min < max, componentwise

                this.x = Math.max( min.x, Math.min( max.x, this.x ) );
                this.y = Math.max( min.y, Math.min( max.y, this.y ) );

                return this;

        }

        clampScalar( minVal, maxVal ) {

                this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
                this.y = Math.max( minVal, Math.min( maxVal, this.y ) );

                return this;

        }

        clampLength( min, max ) {

                const length = this.length();

                return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );

        }

        floor() {

                this.x = Math.floor( this.x );
                this.y = Math.floor( this.y );

                return this;

        }

        ceil() {

                this.x = Math.ceil( this.x );
                this.y = Math.ceil( this.y );

                return this;

        }

        round() {

                this.x = Math.round( this.x );
                this.y = Math.round( this.y );

                return this;

        }

        roundToZero() {

                this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
                this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );

                return this;

        }

        negate() {

                this.x = - this.x;
                this.y = - this.y;

                return this;

        }

        dot( v ) {

                return this.x * v.x + this.y * v.y;

        }

        cross( v ) {

                return this.x * v.y - this.y * v.x;

        }

        lengthSq() {

                return this.x * this.x + this.y * this.y;

        }

        length() {

                return Math.sqrt( this.x * this.x + this.y * this.y );

        }

        manhattanLength() {

                return Math.abs( this.x ) + Math.abs( this.y );

        }

        normalize() {

                return this.divideScalar( this.length() || 1 );

        }

        angle() {

                // computes the angle in radians with respect to the positive x-axis

                const angle = Math.atan2( - this.y, - this.x ) + Math.PI;

                return angle;

        }

        distanceTo( v ) {

                return Math.sqrt( this.distanceToSquared( v ) );

        }

        distanceToSquared( v ) {

                const dx = this.x - v.x, dy = this.y - v.y;
                return dx * dx + dy * dy;

        }

        manhattanDistanceTo( v ) {

                return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );

        }

        setLength( length ) {

                return this.normalize().multiplyScalar( length );

        }

        lerp( v, alpha ) {

                this.x += ( v.x - this.x ) * alpha;
                this.y += ( v.y - this.y ) * alpha;

                return this;

        }

        lerpVectors( v1, v2, alpha ) {

                this.x = v1.x + ( v2.x - v1.x ) * alpha;
                this.y = v1.y + ( v2.y - v1.y ) * alpha;

                return this;

        }

        equals( v ) {

                return ( ( v.x === this.x ) && ( v.y === this.y ) );

        }

        fromArray( array, offset = 0 ) {

                this.x = array[ offset ];
                this.y = array[ offset + 1 ];

                return this;

        }

        toArray( array = [], offset = 0 ) {

                array[ offset ] = this.x;
                array[ offset + 1 ] = this.y;

                return array;

        }

        fromBufferAttribute( attribute, index, offset ) {

                if ( offset !== undefined ) {

                        console.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' );

                }

                this.x = attribute.getX( index );
                this.y = attribute.getY( index );

                return this;

        }

        rotateAround( center, angle ) {

                const c = Math.cos( angle ), s = Math.sin( angle );

                const x = this.x - center.x;
                const y = this.y - center.y;

                this.x = x * c - y * s + center.x;
                this.y = x * s + y * c + center.y;

                return this;

        }

        random() {

                this.x = Math.random();
                this.y = Math.random();

                return this;

        }

    }

    class Matrix3 {

        constructor() {

                Object.defineProperty( this, 'isMatrix3', { value: true } );

                this.elements = [

                        1, 0, 0,
                        0, 1, 0,
                        0, 0, 1

                ];

                if ( arguments.length > 0 ) {

                        console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );

                }

        }

        set( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {

                const te = this.elements;

                te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
                te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
                te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;

                return this;

        }

        identity() {

                this.set(

                        1, 0, 0,
                        0, 1, 0,
                        0, 0, 1

                );

                return this;

        }

        clone() {

                return new this.constructor().fromArray( this.elements );

        }

        copy( m ) {

                const te = this.elements;
                const me = m.elements;

                te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
                te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
                te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];

                return this;

        }

        extractBasis( xAxis, yAxis, zAxis ) {

                xAxis.setFromMatrix3Column( this, 0 );
                yAxis.setFromMatrix3Column( this, 1 );
                zAxis.setFromMatrix3Column( this, 2 );

                return this;

        }

        setFromMatrix4( m ) {

                const me = m.elements;

                this.set(

                        me[ 0 ], me[ 4 ], me[ 8 ],
                        me[ 1 ], me[ 5 ], me[ 9 ],
                        me[ 2 ], me[ 6 ], me[ 10 ]

                );

                return this;

        }

        multiply( m ) {

                return this.multiplyMatrices( this, m );

        }

        premultiply( m ) {

                return this.multiplyMatrices( m, this );

        }

        multiplyMatrices( a, b ) {

                const ae = a.elements;
                const be = b.elements;
                const te = this.elements;

                const a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
                const a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
                const a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];

                const b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
                const b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
                const b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];

                te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
                te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
                te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;

                te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
                te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
                te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;

                te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
                te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
                te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;

                return this;

        }

        multiplyScalar( s ) {

                const te = this.elements;

                te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
                te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
                te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;

                return this;

        }

        determinant() {

                const te = this.elements;

                const a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
                        d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
                        g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];

                return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;

        }

        invert() {

                const te = this.elements,

                        n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ],
                        n12 = te[ 3 ], n22 = te[ 4 ], n32 = te[ 5 ],
                        n13 = te[ 6 ], n23 = te[ 7 ], n33 = te[ 8 ],

                        t11 = n33 * n22 - n32 * n23,
                        t12 = n32 * n13 - n33 * n12,
                        t13 = n23 * n12 - n22 * n13,

                        det = n11 * t11 + n21 * t12 + n31 * t13;

                if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );

                const detInv = 1 / det;

                te[ 0 ] = t11 * detInv;
                te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
                te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;

                te[ 3 ] = t12 * detInv;
                te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
                te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;

                te[ 6 ] = t13 * detInv;
                te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
                te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;

                return this;

        }

        transpose() {

                let tmp;
                const m = this.elements;

                tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
                tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
                tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;

                return this;

        }

        getNormalMatrix( matrix4 ) {

                return this.setFromMatrix4( matrix4 ).copy( this ).invert().transpose();

        }

        transposeIntoArray( r ) {

                const m = this.elements;

                r[ 0 ] = m[ 0 ];
                r[ 1 ] = m[ 3 ];
                r[ 2 ] = m[ 6 ];
                r[ 3 ] = m[ 1 ];
                r[ 4 ] = m[ 4 ];
                r[ 5 ] = m[ 7 ];
                r[ 6 ] = m[ 2 ];
                r[ 7 ] = m[ 5 ];
                r[ 8 ] = m[ 8 ];

                return this;

        }

        setUvTransform( tx, ty, sx, sy, rotation, cx, cy ) {

                const c = Math.cos( rotation );
                const s = Math.sin( rotation );

                this.set(
                        sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
                        - sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
                        0, 0, 1
                );

                return this;

        }

        scale( sx, sy ) {

                const te = this.elements;

                te[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx;
                te[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy;

                return this;

        }

        rotate( theta ) {

                const c = Math.cos( theta );
                const s = Math.sin( theta );

                const te = this.elements;

                const a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ];
                const a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ];

                te[ 0 ] = c * a11 + s * a21;
                te[ 3 ] = c * a12 + s * a22;
                te[ 6 ] = c * a13 + s * a23;

                te[ 1 ] = - s * a11 + c * a21;
                te[ 4 ] = - s * a12 + c * a22;
                te[ 7 ] = - s * a13 + c * a23;

                return this;

        }

        translate( tx, ty ) {

                const te = this.elements;

                te[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ];
                te[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ];

                return this;

        }

        equals( matrix ) {

                const te = this.elements;
                const me = matrix.elements;

                for ( let i = 0; i < 9; i ++ ) {

                        if ( te[ i ] !== me[ i ] ) return false;

                }

                return true;

        }

        fromArray( array, offset = 0 ) {

                for ( let i = 0; i < 9; i ++ ) {

                        this.elements[ i ] = array[ i + offset ];

                }

                return this;

        }

        toArray( array = [], offset = 0 ) {

                const te = this.elements;

                array[ offset ] = te[ 0 ];
                array[ offset + 1 ] = te[ 1 ];
                array[ offset + 2 ] = te[ 2 ];

                array[ offset + 3 ] = te[ 3 ];
                array[ offset + 4 ] = te[ 4 ];
                array[ offset + 5 ] = te[ 5 ];

                array[ offset + 6 ] = te[ 6 ];
                array[ offset + 7 ] = te[ 7 ];
                array[ offset + 8 ] = te[ 8 ];

                return array;

        }

    }

    let _canvas;

    const ImageUtils = {

        getDataURL: function ( image ) {

                if ( /^data:/i.test( image.src ) ) {

                        return image.src;

                }

                if ( typeof HTMLCanvasElement == 'undefined' ) {

                        return image.src;

                }

                let canvas;

                if ( image instanceof HTMLCanvasElement ) {

                        canvas = image;

                } else {

                        if ( _canvas === undefined ) _canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );

                        _canvas.width = image.width;
                        _canvas.height = image.height;

                        const context = _canvas.getContext( '2d' );

                        if ( image instanceof ImageData ) {

                                context.putImageData( image, 0, 0 );

                        } else {

                                context.drawImage( image, 0, 0, image.width, image.height );

                        }

                        canvas = _canvas;

                }

                if ( canvas.width > 2048 || canvas.height > 2048 ) {

                        return canvas.toDataURL( 'image/jpeg', 0.6 );

                } else {

                        return canvas.toDataURL( 'image/png' );

                }

        }

    };

    let textureId = 0;

    function Texture( image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = 1, encoding = LinearEncoding ) {

        Object.defineProperty( this, 'id', { value: textureId ++ } );

        this.uuid = MathUtils.generateUUID();

        this.name = '';

        this.image = image;
        this.mipmaps = [];

        this.mapping = mapping;

        this.wrapS = wrapS;
        this.wrapT = wrapT;

        this.magFilter = magFilter;
        this.minFilter = minFilter;

        this.anisotropy = anisotropy;

        this.format = format;
        this.internalFormat = null;
        this.type = type;

        this.offset = new Vector2( 0, 0 );
        this.repeat = new Vector2( 1, 1 );
        this.center = new Vector2( 0, 0 );
        this.rotation = 0;

        this.matrixAutoUpdate = true;
        this.matrix = new Matrix3();

        this.generateMipmaps = true;
        this.premultiplyAlpha = false;
        this.flipY = true;
        this.unpackAlignment = 4;       // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)

        // Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
        //
        // Also changing the encoding after already used by a Material will not automatically make the Material
        // update. You need to explicitly call Material.needsUpdate to trigger it to recompile.
        this.encoding = encoding;

        this.version = 0;
        this.onUpdate = null;

    }

    Texture.DEFAULT_IMAGE = undefined;
    Texture.DEFAULT_MAPPING = UVMapping;

    Texture.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {

        constructor: Texture,

        isTexture: true,

        updateMatrix: function () {

                this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );

        },

        clone: function () {

                return new this.constructor().copy( this );

        },

        copy: function ( source ) {

                this.name = source.name;

                this.image = source.image;
                this.mipmaps = source.mipmaps.slice( 0 );

                this.mapping = source.mapping;

                this.wrapS = source.wrapS;
                this.wrapT = source.wrapT;

                this.magFilter = source.magFilter;
                this.minFilter = source.minFilter;

                this.anisotropy = source.anisotropy;

                this.format = source.format;
                this.internalFormat = source.internalFormat;
                this.type = source.type;

                this.offset.copy( source.offset );
                this.repeat.copy( source.repeat );
                this.center.copy( source.center );
                this.rotation = source.rotation;

                this.matrixAutoUpdate = source.matrixAutoUpdate;
                this.matrix.copy( source.matrix );

                this.generateMipmaps = source.generateMipmaps;
                this.premultiplyAlpha = source.premultiplyAlpha;
                this.flipY = source.flipY;
                this.unpackAlignment = source.unpackAlignment;
                this.encoding = source.encoding;

                return this;

        },

        toJSON: function ( meta ) {

                const isRootObject = ( meta === undefined || typeof meta === 'string' );

                if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {

                        return meta.textures[ this.uuid ];

                }

                const output = {

                        metadata: {
                                version: 4.5,
                                type: 'Texture',
                                generator: 'Texture.toJSON'
                        },

                        uuid: this.uuid,
                        name: this.name,

                        mapping: this.mapping,

                        repeat: [ this.repeat.x, this.repeat.y ],
                        offset: [ this.offset.x, this.offset.y ],
                        center: [ this.center.x, this.center.y ],
                        rotation: this.rotation,

                        wrap: [ this.wrapS, this.wrapT ],

                        format: this.format,
                        type: this.type,
                        encoding: this.encoding,

                        minFilter: this.minFilter,
                        magFilter: this.magFilter,
                        anisotropy: this.anisotropy,

                        flipY: this.flipY,

                        premultiplyAlpha: this.premultiplyAlpha,
                        unpackAlignment: this.unpackAlignment

                };

                if ( this.image !== undefined ) {

                        // TODO: Move to THREE.Image

                        const image = this.image;

                        if ( image.uuid === undefined ) {

                                image.uuid = MathUtils.generateUUID(); // UGH

                        }

                        if ( ! isRootObject && meta.images[ image.uuid ] === undefined ) {

                                let url;

                                if ( Array.isArray( image ) ) {

                                        // process array of images e.g. CubeTexture

                                        url = [];

                                        for ( let i = 0, l = image.length; i < l; i ++ ) {

                                                // check cube texture with data textures

                                                if ( image[ i ].isDataTexture ) {

                                                        url.push( serializeImage( image[ i ].image ) );

                                                } else {

                                                        url.push( serializeImage( image[ i ] ) );

                                                }

                                        }

                                } else {

                                        // process single image

                                        url = serializeImage( image );

                                }

                                meta.images[ image.uuid ] = {
                                        uuid: image.uuid,
                                        url: url
                                };

                        }

                        output.image = image.uuid;

                }

                if ( ! isRootObject ) {

                        meta.textures[ this.uuid ] = output;

                }

                return output;

        },

        dispose: function () {

                this.dispatchEvent( { type: 'dispose' } );

        },

        transformUv: function ( uv ) {

                if ( this.mapping !== UVMapping ) return uv;

                uv.applyMatrix3( this.matrix );

                if ( uv.x < 0 || uv.x > 1 ) {

                        switch ( this.wrapS ) {

                                case RepeatWrapping:

                                        uv.x = uv.x - Math.floor( uv.x );
                                        break;

                                case ClampToEdgeWrapping:

                                        uv.x = uv.x < 0 ? 0 : 1;
                                        break;

                                case MirroredRepeatWrapping:

                                        if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {

                                                uv.x = Math.ceil( uv.x ) - uv.x;

                                        } else {

                                                uv.x = uv.x - Math.floor( uv.x );

                                        }

                                        break;

                        }

                }

                if ( uv.y < 0 || uv.y > 1 ) {

                        switch ( this.wrapT ) {

                                case RepeatWrapping:

                                        uv.y = uv.y - Math.floor( uv.y );
                                        break;

                                case ClampToEdgeWrapping:

                                        uv.y = uv.y < 0 ? 0 : 1;
                                        break;

                                case MirroredRepeatWrapping:

                                        if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {

                                                uv.y = Math.ceil( uv.y ) - uv.y;

                                        } else {

                                                uv.y = uv.y - Math.floor( uv.y );

                                        }

                                        break;

                        }

                }

                if ( this.flipY ) {

                        uv.y = 1 - uv.y;

                }

                return uv;

        }

    } );

    Object.defineProperty( Texture.prototype, 'needsUpdate', {

        set: function ( value ) {

                if ( value === true ) this.version ++;

        }

    } );

    function serializeImage( image ) {

        if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
                ( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
                ( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {

                // default images

                return ImageUtils.getDataURL( image );

        } else {

                if ( image.data ) {

                        // images of DataTexture

                        return {
                                data: Array.prototype.slice.call( image.data ),
                                width: image.width,
                                height: image.height,
                                type: image.data.constructor.name
                        };

                } else {

                        console.warn( 'THREE.Texture: Unable to serialize Texture.' );
                        return {};

                }

        }

    }

    class Vector4 {

        constructor( x = 0, y = 0, z = 0, w = 1 ) {

                Object.defineProperty( this, 'isVector4', { value: true } );

                this.x = x;
                this.y = y;
                this.z = z;
                this.w = w;

        }

        get width() {

                return this.z;

        }

        set width( value ) {

                this.z = value;

        }

        get height() {

                return this.w;

        }

        set height( value ) {

                this.w = value;

        }

        set( x, y, z, w ) {

                this.x = x;
                this.y = y;
                this.z = z;
                this.w = w;

                return this;

        }

        setScalar( scalar ) {

                this.x = scalar;
                this.y = scalar;
                this.z = scalar;
                this.w = scalar;

                return this;

        }

        setX( x ) {

                this.x = x;

                return this;

        }

        setY( y ) {

                this.y = y;

                return this;

        }

        setZ( z ) {

                this.z = z;

                return this;

        }

        setW( w ) {

                this.w = w;

                return this;

        }

        setComponent( index, value ) {

                switch ( index ) {

                        case 0: this.x = value; break;
                        case 1: this.y = value; break;
                        case 2: this.z = value; break;
                        case 3: this.w = value; break;
                        default: throw new Error( 'index is out of range: ' + index );

                }

                return this;

        }

        getComponent( index ) {

                switch ( index ) {

                        case 0: return this.x;
                        case 1: return this.y;
                        case 2: return this.z;
                        case 3: return this.w;
                        default: throw new Error( 'index is out of range: ' + index );

                }

        }

        clone() {

                return new this.constructor( this.x, this.y, this.z, this.w );

        }

        copy( v ) {

                this.x = v.x;
                this.y = v.y;
                this.z = v.z;
                this.w = ( v.w !== undefined ) ? v.w : 1;

                return this;

        }

        add( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
                        return this.addVectors( v, w );

                }

                this.x += v.x;
                this.y += v.y;
                this.z += v.z;
                this.w += v.w;

                return this;

        }

        addScalar( s ) {

                this.x += s;
                this.y += s;
                this.z += s;
                this.w += s;

                return this;

        }

        addVectors( a, b ) {

                this.x = a.x + b.x;
                this.y = a.y + b.y;
                this.z = a.z + b.z;
                this.w = a.w + b.w;

                return this;

        }

        addScaledVector( v, s ) {

                this.x += v.x * s;
                this.y += v.y * s;
                this.z += v.z * s;
                this.w += v.w * s;

                return this;

        }

        sub( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
                        return this.subVectors( v, w );

                }

                this.x -= v.x;
                this.y -= v.y;
                this.z -= v.z;
                this.w -= v.w;

                return this;

        }

        subScalar( s ) {

                this.x -= s;
                this.y -= s;
                this.z -= s;
                this.w -= s;

                return this;

        }

        subVectors( a, b ) {

                this.x = a.x - b.x;
                this.y = a.y - b.y;
                this.z = a.z - b.z;
                this.w = a.w - b.w;

                return this;

        }

        multiply( v ) {

                this.x *= v.x;
                this.y *= v.y;
                this.z *= v.z;
                this.w *= v.w;

                return this;

        }

        multiplyScalar( scalar ) {

                this.x *= scalar;
                this.y *= scalar;
                this.z *= scalar;
                this.w *= scalar;

                return this;

        }

        applyMatrix4( m ) {

                const x = this.x, y = this.y, z = this.z, w = this.w;
                const e = m.elements;

                this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
                this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
                this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
                this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;

                return this;

        }

        divideScalar( scalar ) {

                return this.multiplyScalar( 1 / scalar );

        }

        setAxisAngleFromQuaternion( q ) {

                // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm

                // q is assumed to be normalized

                this.w = 2 * Math.acos( q.w );

                const s = Math.sqrt( 1 - q.w * q.w );

                if ( s < 0.0001 ) {

                        this.x = 1;
                        this.y = 0;
                        this.z = 0;

                } else {

                        this.x = q.x / s;
                        this.y = q.y / s;
                        this.z = q.z / s;

                }

                return this;

        }

        setAxisAngleFromRotationMatrix( m ) {

                // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm

                // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

                let angle, x, y, z; // variables for result
                const epsilon = 0.01,           // margin to allow for rounding errors
                        epsilon2 = 0.1,         // margin to distinguish between 0 and 180 degrees

                        te = m.elements,

                        m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
                        m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
                        m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];

                if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
                     ( Math.abs( m13 - m31 ) < epsilon ) &&
                     ( Math.abs( m23 - m32 ) < epsilon ) ) {

                        // singularity found
                        // first check for identity matrix which must have +1 for all terms
                        // in leading diagonal and zero in other terms

                        if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
                             ( Math.abs( m13 + m31 ) < epsilon2 ) &&
                             ( Math.abs( m23 + m32 ) < epsilon2 ) &&
                             ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {

                                // this singularity is identity matrix so angle = 0

                                this.set( 1, 0, 0, 0 );

                                return this; // zero angle, arbitrary axis

                        }

                        // otherwise this singularity is angle = 180

                        angle = Math.PI;

                        const xx = ( m11 + 1 ) / 2;
                        const yy = ( m22 + 1 ) / 2;
                        const zz = ( m33 + 1 ) / 2;
                        const xy = ( m12 + m21 ) / 4;
                        const xz = ( m13 + m31 ) / 4;
                        const yz = ( m23 + m32 ) / 4;

                        if ( ( xx > yy ) && ( xx > zz ) ) {

                                // m11 is the largest diagonal term

                                if ( xx < epsilon ) {

                                        x = 0;
                                        y = 0.707106781;
                                        z = 0.707106781;

                                } else {

                                        x = Math.sqrt( xx );
                                        y = xy / x;
                                        z = xz / x;

                                }

                        } else if ( yy > zz ) {

                                // m22 is the largest diagonal term

                                if ( yy < epsilon ) {

                                        x = 0.707106781;
                                        y = 0;
                                        z = 0.707106781;

                                } else {

                                        y = Math.sqrt( yy );
                                        x = xy / y;
                                        z = yz / y;

                                }

                        } else {

                                // m33 is the largest diagonal term so base result on this

                                if ( zz < epsilon ) {

                                        x = 0.707106781;
                                        y = 0.707106781;
                                        z = 0;

                                } else {

                                        z = Math.sqrt( zz );
                                        x = xz / z;
                                        y = yz / z;

                                }

                        }

                        this.set( x, y, z, angle );

                        return this; // return 180 deg rotation

                }

                // as we have reached here there are no singularities so we can handle normally

                let s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
                        ( m13 - m31 ) * ( m13 - m31 ) +
                        ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize

                if ( Math.abs( s ) < 0.001 ) s = 1;

                // prevent divide by zero, should not happen if matrix is orthogonal and should be
                // caught by singularity test above, but I've left it in just in case

                this.x = ( m32 - m23 ) / s;
                this.y = ( m13 - m31 ) / s;
                this.z = ( m21 - m12 ) / s;
                this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );

                return this;

        }

        min( v ) {

                this.x = Math.min( this.x, v.x );
                this.y = Math.min( this.y, v.y );
                this.z = Math.min( this.z, v.z );
                this.w = Math.min( this.w, v.w );

                return this;

        }

        max( v ) {

                this.x = Math.max( this.x, v.x );
                this.y = Math.max( this.y, v.y );
                this.z = Math.max( this.z, v.z );
                this.w = Math.max( this.w, v.w );

                return this;

        }

        clamp( min, max ) {

                // assumes min < max, componentwise

                this.x = Math.max( min.x, Math.min( max.x, this.x ) );
                this.y = Math.max( min.y, Math.min( max.y, this.y ) );
                this.z = Math.max( min.z, Math.min( max.z, this.z ) );
                this.w = Math.max( min.w, Math.min( max.w, this.w ) );

                return this;

        }

        clampScalar( minVal, maxVal ) {

                this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
                this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
                this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
                this.w = Math.max( minVal, Math.min( maxVal, this.w ) );

                return this;

        }

        clampLength( min, max ) {

                const length = this.length();

                return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );

        }

        floor() {

                this.x = Math.floor( this.x );
                this.y = Math.floor( this.y );
                this.z = Math.floor( this.z );
                this.w = Math.floor( this.w );

                return this;

        }

        ceil() {

                this.x = Math.ceil( this.x );
                this.y = Math.ceil( this.y );
                this.z = Math.ceil( this.z );
                this.w = Math.ceil( this.w );

                return this;

        }

        round() {

                this.x = Math.round( this.x );
                this.y = Math.round( this.y );
                this.z = Math.round( this.z );
                this.w = Math.round( this.w );

                return this;

        }

        roundToZero() {

                this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
                this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
                this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
                this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );

                return this;

        }

        negate() {

                this.x = - this.x;
                this.y = - this.y;
                this.z = - this.z;
                this.w = - this.w;

                return this;

        }

        dot( v ) {

                return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;

        }

        lengthSq() {

                return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;

        }

        length() {

                return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );

        }

        manhattanLength() {

                return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );

        }

        normalize() {

                return this.divideScalar( this.length() || 1 );

        }

        setLength( length ) {

                return this.normalize().multiplyScalar( length );

        }

        lerp( v, alpha ) {

                this.x += ( v.x - this.x ) * alpha;
                this.y += ( v.y - this.y ) * alpha;
                this.z += ( v.z - this.z ) * alpha;
                this.w += ( v.w - this.w ) * alpha;

                return this;

        }

        lerpVectors( v1, v2, alpha ) {

                this.x = v1.x + ( v2.x - v1.x ) * alpha;
                this.y = v1.y + ( v2.y - v1.y ) * alpha;
                this.z = v1.z + ( v2.z - v1.z ) * alpha;
                this.w = v1.w + ( v2.w - v1.w ) * alpha;

                return this;

        }

        equals( v ) {

                return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );

        }

        fromArray( array, offset = 0 ) {

                this.x = array[ offset ];
                this.y = array[ offset + 1 ];
                this.z = array[ offset + 2 ];
                this.w = array[ offset + 3 ];

                return this;

        }

        toArray( array = [], offset = 0 ) {

                array[ offset ] = this.x;
                array[ offset + 1 ] = this.y;
                array[ offset + 2 ] = this.z;
                array[ offset + 3 ] = this.w;

                return array;

        }

        fromBufferAttribute( attribute, index, offset ) {

                if ( offset !== undefined ) {

                        console.warn( 'THREE.Vector4: offset has been removed from .fromBufferAttribute().' );

                }

                this.x = attribute.getX( index );
                this.y = attribute.getY( index );
                this.z = attribute.getZ( index );
                this.w = attribute.getW( index );

                return this;

        }

        random() {

                this.x = Math.random();
                this.y = Math.random();
                this.z = Math.random();
                this.w = Math.random();

                return this;

        }

    }

    /*
     In options, we can specify:
     * Texture parameters for an auto-generated target texture
     * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
    */
    class WebGLRenderTarget extends EventDispatcher {

        constructor( width, height, options ) {

                super();

                Object.defineProperty( this, 'isWebGLRenderTarget', { value: true } );

                this.width = width;
                this.height = height;

                this.scissor = new Vector4( 0, 0, width, height );
                this.scissorTest = false;

                this.viewport = new Vector4( 0, 0, width, height );

                options = options || {};

                this.texture = new Texture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );

                this.texture.image = {};
                this.texture.image.width = width;
                this.texture.image.height = height;

                this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
                this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;

                this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;
                this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : false;
                this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null;

        }

        setSize( width, height ) {

                if ( this.width !== width || this.height !== height ) {

                        this.width = width;
                        this.height = height;

                        this.texture.image.width = width;
                        this.texture.image.height = height;

                        this.dispose();

                }

                this.viewport.set( 0, 0, width, height );
                this.scissor.set( 0, 0, width, height );

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( source ) {

                this.width = source.width;
                this.height = source.height;

                this.viewport.copy( source.viewport );

                this.texture = source.texture.clone();

                this.depthBuffer = source.depthBuffer;
                this.stencilBuffer = source.stencilBuffer;
                this.depthTexture = source.depthTexture;

                return this;

        }

        dispose() {

                this.dispatchEvent( { type: 'dispose' } );

        }

    }

    class Quaternion {

        constructor( x = 0, y = 0, z = 0, w = 1 ) {

                Object.defineProperty( this, 'isQuaternion', { value: true } );

                this._x = x;
                this._y = y;
                this._z = z;
                this._w = w;

        }

        static slerp( qa, qb, qm, t ) {

                return qm.copy( qa ).slerp( qb, t );

        }

        static slerpFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {

                // fuzz-free, array-based Quaternion SLERP operation

                let x0 = src0[ srcOffset0 + 0 ],
                        y0 = src0[ srcOffset0 + 1 ],
                        z0 = src0[ srcOffset0 + 2 ],
                        w0 = src0[ srcOffset0 + 3 ];

                const x1 = src1[ srcOffset1 + 0 ],
                        y1 = src1[ srcOffset1 + 1 ],
                        z1 = src1[ srcOffset1 + 2 ],
                        w1 = src1[ srcOffset1 + 3 ];

                if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {

                        let s = 1 - t;
                        const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
                                dir = ( cos >= 0 ? 1 : - 1 ),
                                sqrSin = 1 - cos * cos;

                        // Skip the Slerp for tiny steps to avoid numeric problems:
                        if ( sqrSin > Number.EPSILON ) {

                                const sin = Math.sqrt( sqrSin ),
                                        len = Math.atan2( sin, cos * dir );

                                s = Math.sin( s * len ) / sin;
                                t = Math.sin( t * len ) / sin;

                        }

                        const tDir = t * dir;

                        x0 = x0 * s + x1 * tDir;
                        y0 = y0 * s + y1 * tDir;
                        z0 = z0 * s + z1 * tDir;
                        w0 = w0 * s + w1 * tDir;

                        // Normalize in case we just did a lerp:
                        if ( s === 1 - t ) {

                                const f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );

                                x0 *= f;
                                y0 *= f;
                                z0 *= f;
                                w0 *= f;

                        }

                }

                dst[ dstOffset ] = x0;
                dst[ dstOffset + 1 ] = y0;
                dst[ dstOffset + 2 ] = z0;
                dst[ dstOffset + 3 ] = w0;

        }

        static multiplyQuaternionsFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {

                const x0 = src0[ srcOffset0 ];
                const y0 = src0[ srcOffset0 + 1 ];
                const z0 = src0[ srcOffset0 + 2 ];
                const w0 = src0[ srcOffset0 + 3 ];

                const x1 = src1[ srcOffset1 ];
                const y1 = src1[ srcOffset1 + 1 ];
                const z1 = src1[ srcOffset1 + 2 ];
                const w1 = src1[ srcOffset1 + 3 ];

                dst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
                dst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
                dst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
                dst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;

                return dst;

        }

        get x() {

                return this._x;

        }

        set x( value ) {

                this._x = value;
                this._onChangeCallback();

        }

        get y() {

                return this._y;

        }

        set y( value ) {

                this._y = value;
                this._onChangeCallback();

        }

        get z() {

                return this._z;

        }

        set z( value ) {

                this._z = value;
                this._onChangeCallback();

        }

        get w() {

                return this._w;

        }

        set w( value ) {

                this._w = value;
                this._onChangeCallback();

        }

        set( x, y, z, w ) {

                this._x = x;
                this._y = y;
                this._z = z;
                this._w = w;

                this._onChangeCallback();

                return this;

        }

        clone() {

                return new this.constructor( this._x, this._y, this._z, this._w );

        }

        copy( quaternion ) {

                this._x = quaternion.x;
                this._y = quaternion.y;
                this._z = quaternion.z;
                this._w = quaternion.w;

                this._onChangeCallback();

                return this;

        }

        setFromEuler( euler, update ) {

                if ( ! ( euler && euler.isEuler ) ) {

                        throw new Error( 'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' );

                }

                const x = euler._x, y = euler._y, z = euler._z, order = euler._order;

                // http://www.mathworks.com/matlabcentral/fileexchange/
                //      20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
                //      content/SpinCalc.m

                const cos = Math.cos;
                const sin = Math.sin;

                const c1 = cos( x / 2 );
                const c2 = cos( y / 2 );
                const c3 = cos( z / 2 );

                const s1 = sin( x / 2 );
                const s2 = sin( y / 2 );
                const s3 = sin( z / 2 );

                switch ( order ) {

                        case 'XYZ':
                                this._x = s1 * c2 * c3 + c1 * s2 * s3;
                                this._y = c1 * s2 * c3 - s1 * c2 * s3;
                                this._z = c1 * c2 * s3 + s1 * s2 * c3;
                                this._w = c1 * c2 * c3 - s1 * s2 * s3;
                                break;

                        case 'YXZ':
                                this._x = s1 * c2 * c3 + c1 * s2 * s3;
                                this._y = c1 * s2 * c3 - s1 * c2 * s3;
                                this._z = c1 * c2 * s3 - s1 * s2 * c3;
                                this._w = c1 * c2 * c3 + s1 * s2 * s3;
                                break;

                        case 'ZXY':
                                this._x = s1 * c2 * c3 - c1 * s2 * s3;
                                this._y = c1 * s2 * c3 + s1 * c2 * s3;
                                this._z = c1 * c2 * s3 + s1 * s2 * c3;
                                this._w = c1 * c2 * c3 - s1 * s2 * s3;
                                break;

                        case 'ZYX':
                                this._x = s1 * c2 * c3 - c1 * s2 * s3;
                                this._y = c1 * s2 * c3 + s1 * c2 * s3;
                                this._z = c1 * c2 * s3 - s1 * s2 * c3;
                                this._w = c1 * c2 * c3 + s1 * s2 * s3;
                                break;

                        case 'YZX':
                                this._x = s1 * c2 * c3 + c1 * s2 * s3;
                                this._y = c1 * s2 * c3 + s1 * c2 * s3;
                                this._z = c1 * c2 * s3 - s1 * s2 * c3;
                                this._w = c1 * c2 * c3 - s1 * s2 * s3;
                                break;

                        case 'XZY':
                                this._x = s1 * c2 * c3 - c1 * s2 * s3;
                                this._y = c1 * s2 * c3 - s1 * c2 * s3;
                                this._z = c1 * c2 * s3 + s1 * s2 * c3;
                                this._w = c1 * c2 * c3 + s1 * s2 * s3;
                                break;

                        default:
                                console.warn( 'THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order );

                }

                if ( update !== false ) this._onChangeCallback();

                return this;

        }

        setFromAxisAngle( axis, angle ) {

                // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm

                // assumes axis is normalized

                const halfAngle = angle / 2, s = Math.sin( halfAngle );

                this._x = axis.x * s;
                this._y = axis.y * s;
                this._z = axis.z * s;
                this._w = Math.cos( halfAngle );

                this._onChangeCallback();

                return this;

        }

        setFromRotationMatrix( m ) {

                // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm

                // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

                const te = m.elements,

                        m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
                        m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
                        m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],

                        trace = m11 + m22 + m33;

                if ( trace > 0 ) {

                        const s = 0.5 / Math.sqrt( trace + 1.0 );

                        this._w = 0.25 / s;
                        this._x = ( m32 - m23 ) * s;
                        this._y = ( m13 - m31 ) * s;
                        this._z = ( m21 - m12 ) * s;

                } else if ( m11 > m22 && m11 > m33 ) {

                        const s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );

                        this._w = ( m32 - m23 ) / s;
                        this._x = 0.25 * s;
                        this._y = ( m12 + m21 ) / s;
                        this._z = ( m13 + m31 ) / s;

                } else if ( m22 > m33 ) {

                        const s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );

                        this._w = ( m13 - m31 ) / s;
                        this._x = ( m12 + m21 ) / s;
                        this._y = 0.25 * s;
                        this._z = ( m23 + m32 ) / s;

                } else {

                        const s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );

                        this._w = ( m21 - m12 ) / s;
                        this._x = ( m13 + m31 ) / s;
                        this._y = ( m23 + m32 ) / s;
                        this._z = 0.25 * s;

                }

                this._onChangeCallback();

                return this;

        }

        setFromUnitVectors( vFrom, vTo ) {

                // assumes direction vectors vFrom and vTo are normalized

                const EPS = 0.000001;

                let r = vFrom.dot( vTo ) + 1;

                if ( r < EPS ) {

                        r = 0;

                        if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {

                                this._x = - vFrom.y;
                                this._y = vFrom.x;
                                this._z = 0;
                                this._w = r;

                        } else {

                                this._x = 0;
                                this._y = - vFrom.z;
                                this._z = vFrom.y;
                                this._w = r;

                        }

                } else {

                        // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3

                        this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
                        this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
                        this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
                        this._w = r;

                }

                return this.normalize();

        }

        angleTo( q ) {

                return 2 * Math.acos( Math.abs( MathUtils.clamp( this.dot( q ), - 1, 1 ) ) );

        }

        rotateTowards( q, step ) {

                const angle = this.angleTo( q );

                if ( angle === 0 ) return this;

                const t = Math.min( 1, step / angle );

                this.slerp( q, t );

                return this;

        }

        identity() {

                return this.set( 0, 0, 0, 1 );

        }

        invert() {

                // quaternion is assumed to have unit length

                return this.conjugate();

        }

        conjugate() {

                this._x *= - 1;
                this._y *= - 1;
                this._z *= - 1;

                this._onChangeCallback();

                return this;

        }

        dot( v ) {

                return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;

        }

        lengthSq() {

                return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;

        }

        length() {

                return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );

        }

        normalize() {

                let l = this.length();

                if ( l === 0 ) {

                        this._x = 0;
                        this._y = 0;
                        this._z = 0;
                        this._w = 1;

                } else {

                        l = 1 / l;

                        this._x = this._x * l;
                        this._y = this._y * l;
                        this._z = this._z * l;
                        this._w = this._w * l;

                }

                this._onChangeCallback();

                return this;

        }

        multiply( q, p ) {

                if ( p !== undefined ) {

                        console.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' );
                        return this.multiplyQuaternions( q, p );

                }

                return this.multiplyQuaternions( this, q );

        }

        premultiply( q ) {

                return this.multiplyQuaternions( q, this );

        }

        multiplyQuaternions( a, b ) {

                // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm

                const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
                const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;

                this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
                this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
                this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
                this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;

                this._onChangeCallback();

                return this;

        }

        slerp( qb, t ) {

                if ( t === 0 ) return this;
                if ( t === 1 ) return this.copy( qb );

                const x = this._x, y = this._y, z = this._z, w = this._w;

                // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/

                let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;

                if ( cosHalfTheta < 0 ) {

                        this._w = - qb._w;
                        this._x = - qb._x;
                        this._y = - qb._y;
                        this._z = - qb._z;

                        cosHalfTheta = - cosHalfTheta;

                } else {

                        this.copy( qb );

                }

                if ( cosHalfTheta >= 1.0 ) {

                        this._w = w;
                        this._x = x;
                        this._y = y;
                        this._z = z;

                        return this;

                }

                const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;

                if ( sqrSinHalfTheta <= Number.EPSILON ) {

                        const s = 1 - t;
                        this._w = s * w + t * this._w;
                        this._x = s * x + t * this._x;
                        this._y = s * y + t * this._y;
                        this._z = s * z + t * this._z;

                        this.normalize();
                        this._onChangeCallback();

                        return this;

                }

                const sinHalfTheta = Math.sqrt( sqrSinHalfTheta );
                const halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
                const ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
                        ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;

                this._w = ( w * ratioA + this._w * ratioB );
                this._x = ( x * ratioA + this._x * ratioB );
                this._y = ( y * ratioA + this._y * ratioB );
                this._z = ( z * ratioA + this._z * ratioB );

                this._onChangeCallback();

                return this;

        }

        equals( quaternion ) {

                return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );

        }

        fromArray( array, offset = 0 ) {

                this._x = array[ offset ];
                this._y = array[ offset + 1 ];
                this._z = array[ offset + 2 ];
                this._w = array[ offset + 3 ];

                this._onChangeCallback();

                return this;

        }

        toArray( array = [], offset = 0 ) {

                array[ offset ] = this._x;
                array[ offset + 1 ] = this._y;
                array[ offset + 2 ] = this._z;
                array[ offset + 3 ] = this._w;

                return array;

        }

        fromBufferAttribute( attribute, index ) {

                this._x = attribute.getX( index );
                this._y = attribute.getY( index );
                this._z = attribute.getZ( index );
                this._w = attribute.getW( index );

                return this;

        }

        _onChange( callback ) {

                this._onChangeCallback = callback;

                return this;

        }

        _onChangeCallback() {}

    }

    class Vector3 {

        constructor( x = 0, y = 0, z = 0 ) {

                Object.defineProperty( this, 'isVector3', { value: true } );

                this.x = x;
                this.y = y;
                this.z = z;

        }

        set( x, y, z ) {

                if ( z === undefined ) z = this.z; // sprite.scale.set(x,y)

                this.x = x;
                this.y = y;
                this.z = z;

                return this;

        }

        setScalar( scalar ) {

                this.x = scalar;
                this.y = scalar;
                this.z = scalar;

                return this;

        }

        setX( x ) {

                this.x = x;

                return this;

        }

        setY( y ) {

                this.y = y;

                return this;

        }

        setZ( z ) {

                this.z = z;

                return this;

        }

        setComponent( index, value ) {

                switch ( index ) {

                        case 0: this.x = value; break;
                        case 1: this.y = value; break;
                        case 2: this.z = value; break;
                        default: throw new Error( 'index is out of range: ' + index );

                }

                return this;

        }

        getComponent( index ) {

                switch ( index ) {

                        case 0: return this.x;
                        case 1: return this.y;
                        case 2: return this.z;
                        default: throw new Error( 'index is out of range: ' + index );

                }

        }

        clone() {

                return new this.constructor( this.x, this.y, this.z );

        }

        copy( v ) {

                this.x = v.x;
                this.y = v.y;
                this.z = v.z;

                return this;

        }

        add( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
                        return this.addVectors( v, w );

                }

                this.x += v.x;
                this.y += v.y;
                this.z += v.z;

                return this;

        }

        addScalar( s ) {

                this.x += s;
                this.y += s;
                this.z += s;

                return this;

        }

        addVectors( a, b ) {

                this.x = a.x + b.x;
                this.y = a.y + b.y;
                this.z = a.z + b.z;

                return this;

        }

        addScaledVector( v, s ) {

                this.x += v.x * s;
                this.y += v.y * s;
                this.z += v.z * s;

                return this;

        }

        sub( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
                        return this.subVectors( v, w );

                }

                this.x -= v.x;
                this.y -= v.y;
                this.z -= v.z;

                return this;

        }

        subScalar( s ) {

                this.x -= s;
                this.y -= s;
                this.z -= s;

                return this;

        }

        subVectors( a, b ) {

                this.x = a.x - b.x;
                this.y = a.y - b.y;
                this.z = a.z - b.z;

                return this;

        }

        multiply( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );
                        return this.multiplyVectors( v, w );

                }

                this.x *= v.x;
                this.y *= v.y;
                this.z *= v.z;

                return this;

        }

        multiplyScalar( scalar ) {

                this.x *= scalar;
                this.y *= scalar;
                this.z *= scalar;

                return this;

        }

        multiplyVectors( a, b ) {

                this.x = a.x * b.x;
                this.y = a.y * b.y;
                this.z = a.z * b.z;

                return this;

        }

        applyEuler( euler ) {

                if ( ! ( euler && euler.isEuler ) ) {

                        console.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );

                }

                return this.applyQuaternion( _quaternion.setFromEuler( euler ) );

        }

        applyAxisAngle( axis, angle ) {

                return this.applyQuaternion( _quaternion.setFromAxisAngle( axis, angle ) );

        }

        applyMatrix3( m ) {

                const x = this.x, y = this.y, z = this.z;
                const e = m.elements;

                this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
                this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
                this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;

                return this;

        }

        applyNormalMatrix( m ) {

                return this.applyMatrix3( m ).normalize();

        }

        applyMatrix4( m ) {

                const x = this.x, y = this.y, z = this.z;
                const e = m.elements;

                const w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );

                this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;
                this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;
                this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;

                return this;

        }

        applyQuaternion( q ) {

                const x = this.x, y = this.y, z = this.z;
                const qx = q.x, qy = q.y, qz = q.z, qw = q.w;

                // calculate quat * vector

                const ix = qw * x + qy * z - qz * y;
                const iy = qw * y + qz * x - qx * z;
                const iz = qw * z + qx * y - qy * x;
                const iw = - qx * x - qy * y - qz * z;

                // calculate result * inverse quat

                this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
                this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
                this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;

                return this;

        }

        project( camera ) {

                return this.applyMatrix4( camera.matrixWorldInverse ).applyMatrix4( camera.projectionMatrix );

        }

        unproject( camera ) {

                return this.applyMatrix4( camera.projectionMatrixInverse ).applyMatrix4( camera.matrixWorld );

        }

        transformDirection( m ) {

                // input: THREE.Matrix4 affine matrix
                // vector interpreted as a direction

                const x = this.x, y = this.y, z = this.z;
                const e = m.elements;

                this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
                this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
                this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;

                return this.normalize();

        }

        divide( v ) {

                this.x /= v.x;
                this.y /= v.y;
                this.z /= v.z;

                return this;

        }

        divideScalar( scalar ) {

                return this.multiplyScalar( 1 / scalar );

        }

        min( v ) {

                this.x = Math.min( this.x, v.x );
                this.y = Math.min( this.y, v.y );
                this.z = Math.min( this.z, v.z );

                return this;

        }

        max( v ) {

                this.x = Math.max( this.x, v.x );
                this.y = Math.max( this.y, v.y );
                this.z = Math.max( this.z, v.z );

                return this;

        }

        clamp( min, max ) {

                // assumes min < max, componentwise

                this.x = Math.max( min.x, Math.min( max.x, this.x ) );
                this.y = Math.max( min.y, Math.min( max.y, this.y ) );
                this.z = Math.max( min.z, Math.min( max.z, this.z ) );

                return this;

        }

        clampScalar( minVal, maxVal ) {

                this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
                this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
                this.z = Math.max( minVal, Math.min( maxVal, this.z ) );

                return this;

        }

        clampLength( min, max ) {

                const length = this.length();

                return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );

        }

        floor() {

                this.x = Math.floor( this.x );
                this.y = Math.floor( this.y );
                this.z = Math.floor( this.z );

                return this;

        }

        ceil() {

                this.x = Math.ceil( this.x );
                this.y = Math.ceil( this.y );
                this.z = Math.ceil( this.z );

                return this;

        }

        round() {

                this.x = Math.round( this.x );
                this.y = Math.round( this.y );
                this.z = Math.round( this.z );

                return this;

        }

        roundToZero() {

                this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
                this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
                this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );

                return this;

        }

        negate() {

                this.x = - this.x;
                this.y = - this.y;
                this.z = - this.z;

                return this;

        }

        dot( v ) {

                return this.x * v.x + this.y * v.y + this.z * v.z;

        }

        // TODO lengthSquared?

        lengthSq() {

                return this.x * this.x + this.y * this.y + this.z * this.z;

        }

        length() {

                return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );

        }

        manhattanLength() {

                return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );

        }

        normalize() {

                return this.divideScalar( this.length() || 1 );

        }

        setLength( length ) {

                return this.normalize().multiplyScalar( length );

        }

        lerp( v, alpha ) {

                this.x += ( v.x - this.x ) * alpha;
                this.y += ( v.y - this.y ) * alpha;
                this.z += ( v.z - this.z ) * alpha;

                return this;

        }

        lerpVectors( v1, v2, alpha ) {

                this.x = v1.x + ( v2.x - v1.x ) * alpha;
                this.y = v1.y + ( v2.y - v1.y ) * alpha;
                this.z = v1.z + ( v2.z - v1.z ) * alpha;

                return this;

        }

        cross( v, w ) {

                if ( w !== undefined ) {

                        console.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );
                        return this.crossVectors( v, w );

                }

                return this.crossVectors( this, v );

        }

        crossVectors( a, b ) {

                const ax = a.x, ay = a.y, az = a.z;
                const bx = b.x, by = b.y, bz = b.z;

                this.x = ay * bz - az * by;
                this.y = az * bx - ax * bz;
                this.z = ax * by - ay * bx;

                return this;

        }

        projectOnVector( v ) {

                const denominator = v.lengthSq();

                if ( denominator === 0 ) return this.set( 0, 0, 0 );

                const scalar = v.dot( this ) / denominator;

                return this.copy( v ).multiplyScalar( scalar );

        }

        projectOnPlane( planeNormal ) {

                _vector.copy( this ).projectOnVector( planeNormal );

                return this.sub( _vector );

        }

        reflect( normal ) {

                // reflect incident vector off plane orthogonal to normal
                // normal is assumed to have unit length

                return this.sub( _vector.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );

        }

        angleTo( v ) {

                const denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );

                if ( denominator === 0 ) return Math.PI / 2;

                const theta = this.dot( v ) / denominator;

                // clamp, to handle numerical problems

                return Math.acos( MathUtils.clamp( theta, - 1, 1 ) );

        }

        distanceTo( v ) {

                return Math.sqrt( this.distanceToSquared( v ) );

        }

        distanceToSquared( v ) {

                const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;

                return dx * dx + dy * dy + dz * dz;

        }

        manhattanDistanceTo( v ) {

                return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );

        }

        setFromSpherical( s ) {

                return this.setFromSphericalCoords( s.radius, s.phi, s.theta );

        }

        setFromSphericalCoords( radius, phi, theta ) {

                const sinPhiRadius = Math.sin( phi ) * radius;

                this.x = sinPhiRadius * Math.sin( theta );
                this.y = Math.cos( phi ) * radius;
                this.z = sinPhiRadius * Math.cos( theta );

                return this;

        }

        setFromCylindrical( c ) {

                return this.setFromCylindricalCoords( c.radius, c.theta, c.y );

        }

        setFromCylindricalCoords( radius, theta, y ) {

                this.x = radius * Math.sin( theta );
                this.y = y;
                this.z = radius * Math.cos( theta );

                return this;

        }

        setFromMatrixPosition( m ) {

                const e = m.elements;

                this.x = e[ 12 ];
                this.y = e[ 13 ];
                this.z = e[ 14 ];

                return this;

        }

        setFromMatrixScale( m ) {

                const sx = this.setFromMatrixColumn( m, 0 ).length();
                const sy = this.setFromMatrixColumn( m, 1 ).length();
                const sz = this.setFromMatrixColumn( m, 2 ).length();

                this.x = sx;
                this.y = sy;
                this.z = sz;

                return this;

        }

        setFromMatrixColumn( m, index ) {

                return this.fromArray( m.elements, index * 4 );

        }

        setFromMatrix3Column( m, index ) {

                return this.fromArray( m.elements, index * 3 );

        }

        equals( v ) {

                return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );

        }

        fromArray( array, offset = 0 ) {

                this.x = array[ offset ];
                this.y = array[ offset + 1 ];
                this.z = array[ offset + 2 ];

                return this;

        }

        toArray( array = [], offset = 0 ) {

                array[ offset ] = this.x;
                array[ offset + 1 ] = this.y;
                array[ offset + 2 ] = this.z;

                return array;

        }

        fromBufferAttribute( attribute, index, offset ) {

                if ( offset !== undefined ) {

                        console.warn( 'THREE.Vector3: offset has been removed from .fromBufferAttribute().' );

                }

                this.x = attribute.getX( index );
                this.y = attribute.getY( index );
                this.z = attribute.getZ( index );

                return this;

        }

        random() {

                this.x = Math.random();
                this.y = Math.random();
                this.z = Math.random();

                return this;

        }

    }

    const _vector = /*@__PURE__*/ new Vector3();
    const _quaternion = /*@__PURE__*/ new Quaternion();

    class Box3 {

        constructor( min, max ) {

                Object.defineProperty( this, 'isBox3', { value: true } );

                this.min = ( min !== undefined ) ? min : new Vector3( + Infinity, + Infinity, + Infinity );
                this.max = ( max !== undefined ) ? max : new Vector3( - Infinity, - Infinity, - Infinity );

        }

        set( min, max ) {

                this.min.copy( min );
                this.max.copy( max );

                return this;

        }

        setFromArray( array ) {

                let minX = + Infinity;
                let minY = + Infinity;
                let minZ = + Infinity;

                let maxX = - Infinity;
                let maxY = - Infinity;
                let maxZ = - Infinity;

                for ( let i = 0, l = array.length; i < l; i += 3 ) {

                        const x = array[ i ];
                        const y = array[ i + 1 ];
                        const z = array[ i + 2 ];

                        if ( x < minX ) minX = x;
                        if ( y < minY ) minY = y;
                        if ( z < minZ ) minZ = z;

                        if ( x > maxX ) maxX = x;
                        if ( y > maxY ) maxY = y;
                        if ( z > maxZ ) maxZ = z;

                }

                this.min.set( minX, minY, minZ );
                this.max.set( maxX, maxY, maxZ );

                return this;

        }

        setFromBufferAttribute( attribute ) {

                let minX = + Infinity;
                let minY = + Infinity;
                let minZ = + Infinity;

                let maxX = - Infinity;
                let maxY = - Infinity;
                let maxZ = - Infinity;

                for ( let i = 0, l = attribute.count; i < l; i ++ ) {

                        const x = attribute.getX( i );
                        const y = attribute.getY( i );
                        const z = attribute.getZ( i );

                        if ( x < minX ) minX = x;
                        if ( y < minY ) minY = y;
                        if ( z < minZ ) minZ = z;

                        if ( x > maxX ) maxX = x;
                        if ( y > maxY ) maxY = y;
                        if ( z > maxZ ) maxZ = z;

                }

                this.min.set( minX, minY, minZ );
                this.max.set( maxX, maxY, maxZ );

                return this;

        }

        setFromPoints( points ) {

                this.makeEmpty();

                for ( let i = 0, il = points.length; i < il; i ++ ) {

                        this.expandByPoint( points[ i ] );

                }

                return this;

        }

        setFromCenterAndSize( center, size ) {

                const halfSize = _vector$1.copy( size ).multiplyScalar( 0.5 );

                this.min.copy( center ).sub( halfSize );
                this.max.copy( center ).add( halfSize );

                return this;

        }

        setFromObject( object ) {

                this.makeEmpty();

                return this.expandByObject( object );

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( box ) {

                this.min.copy( box.min );
                this.max.copy( box.max );

                return this;

        }

        makeEmpty() {

                this.min.x = this.min.y = this.min.z = + Infinity;
                this.max.x = this.max.y = this.max.z = - Infinity;

                return this;

        }

        isEmpty() {

                // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes

                return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );

        }

        getCenter( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Box3: .getCenter() target is now required' );
                        target = new Vector3();

                }

                return this.isEmpty() ? target.set( 0, 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );

        }

        getSize( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Box3: .getSize() target is now required' );
                        target = new Vector3();

                }

                return this.isEmpty() ? target.set( 0, 0, 0 ) : target.subVectors( this.max, this.min );

        }

        expandByPoint( point ) {

                this.min.min( point );
                this.max.max( point );

                return this;

        }

        expandByVector( vector ) {

                this.min.sub( vector );
                this.max.add( vector );

                return this;

        }

        expandByScalar( scalar ) {

                this.min.addScalar( - scalar );
                this.max.addScalar( scalar );

                return this;

        }

        expandByObject( object ) {

                // Computes the world-axis-aligned bounding box of an object (including its children),
                // accounting for both the object's, and children's, world transforms

                object.updateWorldMatrix( false, false );

                const geometry = object.geometry;

                if ( geometry !== undefined ) {

                        if ( geometry.boundingBox === null ) {

                                geometry.computeBoundingBox();

                        }

                        _box.copy( geometry.boundingBox );
                        _box.applyMatrix4( object.matrixWorld );

                        this.union( _box );

                }

                const children = object.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        this.expandByObject( children[ i ] );

                }

                return this;

        }

        containsPoint( point ) {

                return point.x < this.min.x || point.x > this.max.x ||
                        point.y < this.min.y || point.y > this.max.y ||
                        point.z < this.min.z || point.z > this.max.z ? false : true;

        }

        containsBox( box ) {

                return this.min.x <= box.min.x && box.max.x <= this.max.x &&
                        this.min.y <= box.min.y && box.max.y <= this.max.y &&
                        this.min.z <= box.min.z && box.max.z <= this.max.z;

        }

        getParameter( point, target ) {

                // This can potentially have a divide by zero if the box
                // has a size dimension of 0.

                if ( target === undefined ) {

                        console.warn( 'THREE.Box3: .getParameter() target is now required' );
                        target = new Vector3();

                }

                return target.set(
                        ( point.x - this.min.x ) / ( this.max.x - this.min.x ),
                        ( point.y - this.min.y ) / ( this.max.y - this.min.y ),
                        ( point.z - this.min.z ) / ( this.max.z - this.min.z )
                );

        }

        intersectsBox( box ) {

                // using 6 splitting planes to rule out intersections.
                return box.max.x < this.min.x || box.min.x > this.max.x ||
                        box.max.y < this.min.y || box.min.y > this.max.y ||
                        box.max.z < this.min.z || box.min.z > this.max.z ? false : true;

        }

        intersectsSphere( sphere ) {

                // Find the point on the AABB closest to the sphere center.
                this.clampPoint( sphere.center, _vector$1 );

                // If that point is inside the sphere, the AABB and sphere intersect.
                return _vector$1.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );

        }

        intersectsPlane( plane ) {

                // We compute the minimum and maximum dot product values. If those values
                // are on the same side (back or front) of the plane, then there is no intersection.

                let min, max;

                if ( plane.normal.x > 0 ) {

                        min = plane.normal.x * this.min.x;
                        max = plane.normal.x * this.max.x;

                } else {

                        min = plane.normal.x * this.max.x;
                        max = plane.normal.x * this.min.x;

                }

                if ( plane.normal.y > 0 ) {

                        min += plane.normal.y * this.min.y;
                        max += plane.normal.y * this.max.y;

                } else {

                        min += plane.normal.y * this.max.y;
                        max += plane.normal.y * this.min.y;

                }

                if ( plane.normal.z > 0 ) {

                        min += plane.normal.z * this.min.z;
                        max += plane.normal.z * this.max.z;

                } else {

                        min += plane.normal.z * this.max.z;
                        max += plane.normal.z * this.min.z;

                }

                return ( min <= - plane.constant && max >= - plane.constant );

        }

        intersectsTriangle( triangle ) {

                if ( this.isEmpty() ) {

                        return false;

                }

                // compute box center and extents
                this.getCenter( _center );
                _extents.subVectors( this.max, _center );

                // translate triangle to aabb origin
                _v0.subVectors( triangle.a, _center );
                _v1.subVectors( triangle.b, _center );
                _v2.subVectors( triangle.c, _center );

                // compute edge vectors for triangle
                _f0.subVectors( _v1, _v0 );
                _f1.subVectors( _v2, _v1 );
                _f2.subVectors( _v0, _v2 );

                // test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
                // make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
                // axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
                let axes = [
                        0, - _f0.z, _f0.y, 0, - _f1.z, _f1.y, 0, - _f2.z, _f2.y,
                        _f0.z, 0, - _f0.x, _f1.z, 0, - _f1.x, _f2.z, 0, - _f2.x,
                        - _f0.y, _f0.x, 0, - _f1.y, _f1.x, 0, - _f2.y, _f2.x, 0
                ];
                if ( ! satForAxes( axes, _v0, _v1, _v2, _extents ) ) {

                        return false;

                }

                // test 3 face normals from the aabb
                axes = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];
                if ( ! satForAxes( axes, _v0, _v1, _v2, _extents ) ) {

                        return false;

                }

                // finally testing the face normal of the triangle
                // use already existing triangle edge vectors here
                _triangleNormal.crossVectors( _f0, _f1 );
                axes = [ _triangleNormal.x, _triangleNormal.y, _triangleNormal.z ];

                return satForAxes( axes, _v0, _v1, _v2, _extents );

        }

        clampPoint( point, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Box3: .clampPoint() target is now required' );
                        target = new Vector3();

                }

                return target.copy( point ).clamp( this.min, this.max );

        }

        distanceToPoint( point ) {

                const clampedPoint = _vector$1.copy( point ).clamp( this.min, this.max );

                return clampedPoint.sub( point ).length();

        }

        getBoundingSphere( target ) {

                if ( target === undefined ) {

                        console.error( 'THREE.Box3: .getBoundingSphere() target is now required' );
                        //target = new Sphere(); // removed to avoid cyclic dependency

                }

                this.getCenter( target.center );

                target.radius = this.getSize( _vector$1 ).length() * 0.5;

                return target;

        }

        intersect( box ) {

                this.min.max( box.min );
                this.max.min( box.max );

                // ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
                if ( this.isEmpty() ) this.makeEmpty();

                return this;

        }

        union( box ) {

                this.min.min( box.min );
                this.max.max( box.max );

                return this;

        }

        applyMatrix4( matrix ) {

                // transform of empty box is an empty box.
                if ( this.isEmpty() ) return this;

                // NOTE: I am using a binary pattern to specify all 2^3 combinations below
                _points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000
                _points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001
                _points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010
                _points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011
                _points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100
                _points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101
                _points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110
                _points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111

                this.setFromPoints( _points );

                return this;

        }

        translate( offset ) {

                this.min.add( offset );
                this.max.add( offset );

                return this;

        }

        equals( box ) {

                return box.min.equals( this.min ) && box.max.equals( this.max );

        }

    }

    function satForAxes( axes, v0, v1, v2, extents ) {

        for ( let i = 0, j = axes.length - 3; i <= j; i += 3 ) {

                _testAxis.fromArray( axes, i );
                // project the aabb onto the seperating axis
                const r = extents.x * Math.abs( _testAxis.x ) + extents.y * Math.abs( _testAxis.y ) + extents.z * Math.abs( _testAxis.z );
                // project all 3 vertices of the triangle onto the seperating axis
                const p0 = v0.dot( _testAxis );
                const p1 = v1.dot( _testAxis );
                const p2 = v2.dot( _testAxis );
                // actual test, basically see if either of the most extreme of the triangle points intersects r
                if ( Math.max( - Math.max( p0, p1, p2 ), Math.min( p0, p1, p2 ) ) > r ) {

                        // points of the projected triangle are outside the projected half-length of the aabb
                        // the axis is seperating and we can exit
                        return false;

                }

        }

        return true;

    }

    const _points = [
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3(),
        /*@__PURE__*/ new Vector3()
    ];

    const _vector$1 = /*@__PURE__*/ new Vector3();

    const _box = /*@__PURE__*/ new Box3();

    // triangle centered vertices

    const _v0 = /*@__PURE__*/ new Vector3();
    const _v1 = /*@__PURE__*/ new Vector3();
    const _v2 = /*@__PURE__*/ new Vector3();

    // triangle edge vectors

    const _f0 = /*@__PURE__*/ new Vector3();
    const _f1 = /*@__PURE__*/ new Vector3();
    const _f2 = /*@__PURE__*/ new Vector3();

    const _center = /*@__PURE__*/ new Vector3();
    const _extents = /*@__PURE__*/ new Vector3();
    const _triangleNormal = /*@__PURE__*/ new Vector3();
    const _testAxis = /*@__PURE__*/ new Vector3();

    const _box$1 = /*@__PURE__*/ new Box3();

    class Sphere {

        constructor( center, radius ) {

                this.center = ( center !== undefined ) ? center : new Vector3();
                this.radius = ( radius !== undefined ) ? radius : - 1;

        }

        set( center, radius ) {

                this.center.copy( center );
                this.radius = radius;

                return this;

        }

        setFromPoints( points, optionalCenter ) {

                const center = this.center;

                if ( optionalCenter !== undefined ) {

                        center.copy( optionalCenter );

                } else {

                        _box$1.setFromPoints( points ).getCenter( center );

                }

                let maxRadiusSq = 0;

                for ( let i = 0, il = points.length; i < il; i ++ ) {

                        maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );

                }

                this.radius = Math.sqrt( maxRadiusSq );

                return this;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( sphere ) {

                this.center.copy( sphere.center );
                this.radius = sphere.radius;

                return this;

        }

        isEmpty() {

                return ( this.radius < 0 );

        }

        makeEmpty() {

                this.center.set( 0, 0, 0 );
                this.radius = - 1;

                return this;

        }

        containsPoint( point ) {

                return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );

        }

        distanceToPoint( point ) {

                return ( point.distanceTo( this.center ) - this.radius );

        }

        intersectsSphere( sphere ) {

                const radiusSum = this.radius + sphere.radius;

                return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );

        }

        intersectsBox( box ) {

                return box.intersectsSphere( this );

        }

        intersectsPlane( plane ) {

                return Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius;

        }

        clampPoint( point, target ) {

                const deltaLengthSq = this.center.distanceToSquared( point );

                if ( target === undefined ) {

                        console.warn( 'THREE.Sphere: .clampPoint() target is now required' );
                        target = new Vector3();

                }

                target.copy( point );

                if ( deltaLengthSq > ( this.radius * this.radius ) ) {

                        target.sub( this.center ).normalize();
                        target.multiplyScalar( this.radius ).add( this.center );

                }

                return target;

        }

        getBoundingBox( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Sphere: .getBoundingBox() target is now required' );
                        target = new Box3();

                }

                if ( this.isEmpty() ) {

                        // Empty sphere produces empty bounding box
                        target.makeEmpty();
                        return target;

                }

                target.set( this.center, this.center );
                target.expandByScalar( this.radius );

                return target;

        }

        applyMatrix4( matrix ) {

                this.center.applyMatrix4( matrix );
                this.radius = this.radius * matrix.getMaxScaleOnAxis();

                return this;

        }

        translate( offset ) {

                this.center.add( offset );

                return this;

        }

        equals( sphere ) {

                return sphere.center.equals( this.center ) && ( sphere.radius === this.radius );

        }

    }

    const _vector$2 = /*@__PURE__*/ new Vector3();
    const _segCenter = /*@__PURE__*/ new Vector3();
    const _segDir = /*@__PURE__*/ new Vector3();
    const _diff = /*@__PURE__*/ new Vector3();

    const _edge1 = /*@__PURE__*/ new Vector3();
    const _edge2 = /*@__PURE__*/ new Vector3();
    const _normal = /*@__PURE__*/ new Vector3();

    class Ray {

        constructor( origin, direction ) {

                this.origin = ( origin !== undefined ) ? origin : new Vector3();
                this.direction = ( direction !== undefined ) ? direction : new Vector3( 0, 0, - 1 );

        }

        set( origin, direction ) {

                this.origin.copy( origin );
                this.direction.copy( direction );

                return this;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( ray ) {

                this.origin.copy( ray.origin );
                this.direction.copy( ray.direction );

                return this;

        }

        at( t, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Ray: .at() target is now required' );
                        target = new Vector3();

                }

                return target.copy( this.direction ).multiplyScalar( t ).add( this.origin );

        }

        lookAt( v ) {

                this.direction.copy( v ).sub( this.origin ).normalize();

                return this;

        }

        recast( t ) {

                this.origin.copy( this.at( t, _vector$2 ) );

                return this;

        }

        closestPointToPoint( point, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Ray: .closestPointToPoint() target is now required' );
                        target = new Vector3();

                }

                target.subVectors( point, this.origin );

                const directionDistance = target.dot( this.direction );

                if ( directionDistance < 0 ) {

                        return target.copy( this.origin );

                }

                return target.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );

        }

        distanceToPoint( point ) {

                return Math.sqrt( this.distanceSqToPoint( point ) );

        }

        distanceSqToPoint( point ) {

                const directionDistance = _vector$2.subVectors( point, this.origin ).dot( this.direction );

                // point behind the ray

                if ( directionDistance < 0 ) {

                        return this.origin.distanceToSquared( point );

                }

                _vector$2.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );

                return _vector$2.distanceToSquared( point );

        }

        distanceSqToSegment( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {

                // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteDistRaySegment.h
                // It returns the min distance between the ray and the segment
                // defined by v0 and v1
                // It can also set two optional targets :
                // - The closest point on the ray
                // - The closest point on the segment

                _segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );
                _segDir.copy( v1 ).sub( v0 ).normalize();
                _diff.copy( this.origin ).sub( _segCenter );

                const segExtent = v0.distanceTo( v1 ) * 0.5;
                const a01 = - this.direction.dot( _segDir );
                const b0 = _diff.dot( this.direction );
                const b1 = - _diff.dot( _segDir );
                const c = _diff.lengthSq();
                const det = Math.abs( 1 - a01 * a01 );
                let s0, s1, sqrDist, extDet;

                if ( det > 0 ) {

                        // The ray and segment are not parallel.

                        s0 = a01 * b1 - b0;
                        s1 = a01 * b0 - b1;
                        extDet = segExtent * det;

                        if ( s0 >= 0 ) {

                                if ( s1 >= - extDet ) {

                                        if ( s1 <= extDet ) {

                                                // region 0
                                                // Minimum at interior points of ray and segment.

                                                const invDet = 1 / det;
                                                s0 *= invDet;
                                                s1 *= invDet;
                                                sqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;

                                        } else {

                                                // region 1

                                                s1 = segExtent;
                                                s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
                                                sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;

                                        }

                                } else {

                                        // region 5

                                        s1 = - segExtent;
                                        s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
                                        sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;

                                }

                        } else {

                                if ( s1 <= - extDet ) {

                                        // region 4

                                        s0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );
                                        s1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
                                        sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;

                                } else if ( s1 <= extDet ) {

                                        // region 3

                                        s0 = 0;
                                        s1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );
                                        sqrDist = s1 * ( s1 + 2 * b1 ) + c;

                                } else {

                                        // region 2

                                        s0 = Math.max( 0, - ( a01 * segExtent + b0 ) );
                                        s1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
                                        sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;

                                }

                        }

                } else {

                        // Ray and segment are parallel.

                        s1 = ( a01 > 0 ) ? - segExtent : segExtent;
                        s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
                        sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;

                }

                if ( optionalPointOnRay ) {

                        optionalPointOnRay.copy( this.direction ).multiplyScalar( s0 ).add( this.origin );

                }

                if ( optionalPointOnSegment ) {

                        optionalPointOnSegment.copy( _segDir ).multiplyScalar( s1 ).add( _segCenter );

                }

                return sqrDist;

        }

        intersectSphere( sphere, target ) {

                _vector$2.subVectors( sphere.center, this.origin );
                const tca = _vector$2.dot( this.direction );
                const d2 = _vector$2.dot( _vector$2 ) - tca * tca;
                const radius2 = sphere.radius * sphere.radius;

                if ( d2 > radius2 ) return null;

                const thc = Math.sqrt( radius2 - d2 );

                // t0 = first intersect point - entrance on front of sphere
                const t0 = tca - thc;

                // t1 = second intersect point - exit point on back of sphere
                const t1 = tca + thc;

                // test to see if both t0 and t1 are behind the ray - if so, return null
                if ( t0 < 0 && t1 < 0 ) return null;

                // test to see if t0 is behind the ray:
                // if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
                // in order to always return an intersect point that is in front of the ray.
                if ( t0 < 0 ) return this.at( t1, target );

                // else t0 is in front of the ray, so return the first collision point scaled by t0
                return this.at( t0, target );

        }

        intersectsSphere( sphere ) {

                return this.distanceSqToPoint( sphere.center ) <= ( sphere.radius * sphere.radius );

        }

        distanceToPlane( plane ) {

                const denominator = plane.normal.dot( this.direction );

                if ( denominator === 0 ) {

                        // line is coplanar, return origin
                        if ( plane.distanceToPoint( this.origin ) === 0 ) {

                                return 0;

                        }

                        // Null is preferable to undefined since undefined means.... it is undefined

                        return null;

                }

                const t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;

                // Return if the ray never intersects the plane

                return t >= 0 ? t : null;

        }

        intersectPlane( plane, target ) {

                const t = this.distanceToPlane( plane );

                if ( t === null ) {

                        return null;

                }

                return this.at( t, target );

        }

        intersectsPlane( plane ) {

                // check if the ray lies on the plane first

                const distToPoint = plane.distanceToPoint( this.origin );

                if ( distToPoint === 0 ) {

                        return true;

                }

                const denominator = plane.normal.dot( this.direction );

                if ( denominator * distToPoint < 0 ) {

                        return true;

                }

                // ray origin is behind the plane (and is pointing behind it)

                return false;

        }

        intersectBox( box, target ) {

                let tmin, tmax, tymin, tymax, tzmin, tzmax;

                const invdirx = 1 / this.direction.x,
                        invdiry = 1 / this.direction.y,
                        invdirz = 1 / this.direction.z;

                const origin = this.origin;

                if ( invdirx >= 0 ) {

                        tmin = ( box.min.x - origin.x ) * invdirx;
                        tmax = ( box.max.x - origin.x ) * invdirx;

                } else {

                        tmin = ( box.max.x - origin.x ) * invdirx;
                        tmax = ( box.min.x - origin.x ) * invdirx;

                }

                if ( invdiry >= 0 ) {

                        tymin = ( box.min.y - origin.y ) * invdiry;
                        tymax = ( box.max.y - origin.y ) * invdiry;

                } else {

                        tymin = ( box.max.y - origin.y ) * invdiry;
                        tymax = ( box.min.y - origin.y ) * invdiry;

                }

                if ( ( tmin > tymax ) || ( tymin > tmax ) ) return null;

                // These lines also handle the case where tmin or tmax is NaN
                // (result of 0 * Infinity). x !== x returns true if x is NaN

                if ( tymin > tmin || tmin !== tmin ) tmin = tymin;

                if ( tymax < tmax || tmax !== tmax ) tmax = tymax;

                if ( invdirz >= 0 ) {

                        tzmin = ( box.min.z - origin.z ) * invdirz;
                        tzmax = ( box.max.z - origin.z ) * invdirz;

                } else {

                        tzmin = ( box.max.z - origin.z ) * invdirz;
                        tzmax = ( box.min.z - origin.z ) * invdirz;

                }

                if ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null;

                if ( tzmin > tmin || tmin !== tmin ) tmin = tzmin;

                if ( tzmax < tmax || tmax !== tmax ) tmax = tzmax;

                //return point closest to the ray (positive side)

                if ( tmax < 0 ) return null;

                return this.at( tmin >= 0 ? tmin : tmax, target );

        }

        intersectsBox( box ) {

                return this.intersectBox( box, _vector$2 ) !== null;

        }

        intersectTriangle( a, b, c, backfaceCulling, target ) {

                // Compute the offset origin, edges, and normal.

                // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h

                _edge1.subVectors( b, a );
                _edge2.subVectors( c, a );
                _normal.crossVectors( _edge1, _edge2 );

                // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
                // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
                //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
                //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
                //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
                let DdN = this.direction.dot( _normal );
                let sign;

                if ( DdN > 0 ) {

                        if ( backfaceCulling ) return null;
                        sign = 1;

                } else if ( DdN < 0 ) {

                        sign = - 1;
                        DdN = - DdN;

                } else {

                        return null;

                }

                _diff.subVectors( this.origin, a );
                const DdQxE2 = sign * this.direction.dot( _edge2.crossVectors( _diff, _edge2 ) );

                // b1 < 0, no intersection
                if ( DdQxE2 < 0 ) {

                        return null;

                }

                const DdE1xQ = sign * this.direction.dot( _edge1.cross( _diff ) );

                // b2 < 0, no intersection
                if ( DdE1xQ < 0 ) {

                        return null;

                }

                // b1+b2 > 1, no intersection
                if ( DdQxE2 + DdE1xQ > DdN ) {

                        return null;

                }

                // Line intersects triangle, check if ray does.
                const QdN = - sign * _diff.dot( _normal );

                // t < 0, no intersection
                if ( QdN < 0 ) {

                        return null;

                }

                // Ray intersects triangle.
                return this.at( QdN / DdN, target );

        }

        applyMatrix4( matrix4 ) {

                this.origin.applyMatrix4( matrix4 );
                this.direction.transformDirection( matrix4 );

                return this;

        }

        equals( ray ) {

                return ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );

        }

    }

    class Matrix4 {

        constructor() {

                Object.defineProperty( this, 'isMatrix4', { value: true } );

                this.elements = [

                        1, 0, 0, 0,
                        0, 1, 0, 0,
                        0, 0, 1, 0,
                        0, 0, 0, 1

                ];

                if ( arguments.length > 0 ) {

                        console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );

                }

        }

        set( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {

                const te = this.elements;

                te[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;
                te[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;
                te[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;
                te[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;

                return this;

        }

        identity() {

                this.set(

                        1, 0, 0, 0,
                        0, 1, 0, 0,
                        0, 0, 1, 0,
                        0, 0, 0, 1

                );

                return this;

        }

        clone() {

                return new Matrix4().fromArray( this.elements );

        }

        copy( m ) {

                const te = this.elements;
                const me = m.elements;

                te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];
                te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];
                te[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];
                te[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];

                return this;

        }

        copyPosition( m ) {

                const te = this.elements, me = m.elements;

                te[ 12 ] = me[ 12 ];
                te[ 13 ] = me[ 13 ];
                te[ 14 ] = me[ 14 ];

                return this;

        }

        setFromMatrix3( m ) {

                const me = m.elements;

                this.set(

                        me[ 0 ], me[ 3 ], me[ 6 ], 0,
                        me[ 1 ], me[ 4 ], me[ 7 ], 0,
                        me[ 2 ], me[ 5 ], me[ 8 ], 0,
                        0, 0, 0, 1

                );

                return this;

        }

        extractBasis( xAxis, yAxis, zAxis ) {

                xAxis.setFromMatrixColumn( this, 0 );
                yAxis.setFromMatrixColumn( this, 1 );
                zAxis.setFromMatrixColumn( this, 2 );

                return this;

        }

        makeBasis( xAxis, yAxis, zAxis ) {

                this.set(
                        xAxis.x, yAxis.x, zAxis.x, 0,
                        xAxis.y, yAxis.y, zAxis.y, 0,
                        xAxis.z, yAxis.z, zAxis.z, 0,
                        0, 0, 0, 1
                );

                return this;

        }

        extractRotation( m ) {

                // this method does not support reflection matrices

                const te = this.elements;
                const me = m.elements;

                const scaleX = 1 / _v1$1.setFromMatrixColumn( m, 0 ).length();
                const scaleY = 1 / _v1$1.setFromMatrixColumn( m, 1 ).length();
                const scaleZ = 1 / _v1$1.setFromMatrixColumn( m, 2 ).length();

                te[ 0 ] = me[ 0 ] * scaleX;
                te[ 1 ] = me[ 1 ] * scaleX;
                te[ 2 ] = me[ 2 ] * scaleX;
                te[ 3 ] = 0;

                te[ 4 ] = me[ 4 ] * scaleY;
                te[ 5 ] = me[ 5 ] * scaleY;
                te[ 6 ] = me[ 6 ] * scaleY;
                te[ 7 ] = 0;

                te[ 8 ] = me[ 8 ] * scaleZ;
                te[ 9 ] = me[ 9 ] * scaleZ;
                te[ 10 ] = me[ 10 ] * scaleZ;
                te[ 11 ] = 0;

                te[ 12 ] = 0;
                te[ 13 ] = 0;
                te[ 14 ] = 0;
                te[ 15 ] = 1;

                return this;

        }

        makeRotationFromEuler( euler ) {

                if ( ! ( euler && euler.isEuler ) ) {

                        console.error( 'THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );

                }

                const te = this.elements;

                const x = euler.x, y = euler.y, z = euler.z;
                const a = Math.cos( x ), b = Math.sin( x );
                const c = Math.cos( y ), d = Math.sin( y );
                const e = Math.cos( z ), f = Math.sin( z );

                if ( euler.order === 'XYZ' ) {

                        const ae = a * e, af = a * f, be = b * e, bf = b * f;

                        te[ 0 ] = c * e;
                        te[ 4 ] = - c * f;
                        te[ 8 ] = d;

                        te[ 1 ] = af + be * d;
                        te[ 5 ] = ae - bf * d;
                        te[ 9 ] = - b * c;

                        te[ 2 ] = bf - ae * d;
                        te[ 6 ] = be + af * d;
                        te[ 10 ] = a * c;

                } else if ( euler.order === 'YXZ' ) {

                        const ce = c * e, cf = c * f, de = d * e, df = d * f;

                        te[ 0 ] = ce + df * b;
                        te[ 4 ] = de * b - cf;
                        te[ 8 ] = a * d;

                        te[ 1 ] = a * f;
                        te[ 5 ] = a * e;
                        te[ 9 ] = - b;

                        te[ 2 ] = cf * b - de;
                        te[ 6 ] = df + ce * b;
                        te[ 10 ] = a * c;

                } else if ( euler.order === 'ZXY' ) {

                        const ce = c * e, cf = c * f, de = d * e, df = d * f;

                        te[ 0 ] = ce - df * b;
                        te[ 4 ] = - a * f;
                        te[ 8 ] = de + cf * b;

                        te[ 1 ] = cf + de * b;
                        te[ 5 ] = a * e;
                        te[ 9 ] = df - ce * b;

                        te[ 2 ] = - a * d;
                        te[ 6 ] = b;
                        te[ 10 ] = a * c;

                } else if ( euler.order === 'ZYX' ) {

                        const ae = a * e, af = a * f, be = b * e, bf = b * f;

                        te[ 0 ] = c * e;
                        te[ 4 ] = be * d - af;
                        te[ 8 ] = ae * d + bf;

                        te[ 1 ] = c * f;
                        te[ 5 ] = bf * d + ae;
                        te[ 9 ] = af * d - be;

                        te[ 2 ] = - d;
                        te[ 6 ] = b * c;
                        te[ 10 ] = a * c;

                } else if ( euler.order === 'YZX' ) {

                        const ac = a * c, ad = a * d, bc = b * c, bd = b * d;

                        te[ 0 ] = c * e;
                        te[ 4 ] = bd - ac * f;
                        te[ 8 ] = bc * f + ad;

                        te[ 1 ] = f;
                        te[ 5 ] = a * e;
                        te[ 9 ] = - b * e;

                        te[ 2 ] = - d * e;
                        te[ 6 ] = ad * f + bc;
                        te[ 10 ] = ac - bd * f;

                } else if ( euler.order === 'XZY' ) {

                        const ac = a * c, ad = a * d, bc = b * c, bd = b * d;

                        te[ 0 ] = c * e;
                        te[ 4 ] = - f;
                        te[ 8 ] = d * e;

                        te[ 1 ] = ac * f + bd;
                        te[ 5 ] = a * e;
                        te[ 9 ] = ad * f - bc;

                        te[ 2 ] = bc * f - ad;
                        te[ 6 ] = b * e;
                        te[ 10 ] = bd * f + ac;

                }

                // bottom row
                te[ 3 ] = 0;
                te[ 7 ] = 0;
                te[ 11 ] = 0;

                // last column
                te[ 12 ] = 0;
                te[ 13 ] = 0;
                te[ 14 ] = 0;
                te[ 15 ] = 1;

                return this;

        }

        makeRotationFromQuaternion( q ) {

                return this.compose( _zero, q, _one );

        }

        lookAt( eye, target, up ) {

                const te = this.elements;

                _z.subVectors( eye, target );

                if ( _z.lengthSq() === 0 ) {

                        // eye and target are in the same position

                        _z.z = 1;

                }

                _z.normalize();
                _x.crossVectors( up, _z );

                if ( _x.lengthSq() === 0 ) {

                        // up and z are parallel

                        if ( Math.abs( up.z ) === 1 ) {

                                _z.x += 0.0001;

                        } else {

                                _z.z += 0.0001;

                        }

                        _z.normalize();
                        _x.crossVectors( up, _z );

                }

                _x.normalize();
                _y.crossVectors( _z, _x );

                te[ 0 ] = _x.x; te[ 4 ] = _y.x; te[ 8 ] = _z.x;
                te[ 1 ] = _x.y; te[ 5 ] = _y.y; te[ 9 ] = _z.y;
                te[ 2 ] = _x.z; te[ 6 ] = _y.z; te[ 10 ] = _z.z;

                return this;

        }

        multiply( m, n ) {

                if ( n !== undefined ) {

                        console.warn( 'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' );
                        return this.multiplyMatrices( m, n );

                }

                return this.multiplyMatrices( this, m );

        }

        premultiply( m ) {

                return this.multiplyMatrices( m, this );

        }

        multiplyMatrices( a, b ) {

                const ae = a.elements;
                const be = b.elements;
                const te = this.elements;

                const a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];
                const a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];
                const a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];
                const a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];

                const b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];
                const b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];
                const b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];
                const b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];

                te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
                te[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
                te[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
                te[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;

                te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
                te[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
                te[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
                te[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;

                te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
                te[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
                te[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
                te[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;

                te[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
                te[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
                te[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
                te[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;

                return this;

        }

        multiplyScalar( s ) {

                const te = this.elements;

                te[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;
                te[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;
                te[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;
                te[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;

                return this;

        }

        determinant() {

                const te = this.elements;

                const n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];
                const n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];
                const n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];
                const n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];

                //TODO: make this more efficient
                //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )

                return (
                        n41 * (
                                + n14 * n23 * n32
                                 - n13 * n24 * n32
                                 - n14 * n22 * n33
                                 + n12 * n24 * n33
                                 + n13 * n22 * n34
                                 - n12 * n23 * n34
                        ) +
                        n42 * (
                                + n11 * n23 * n34
                                 - n11 * n24 * n33
                                 + n14 * n21 * n33
                                 - n13 * n21 * n34
                                 + n13 * n24 * n31
                                 - n14 * n23 * n31
                        ) +
                        n43 * (
                                + n11 * n24 * n32
                                 - n11 * n22 * n34
                                 - n14 * n21 * n32
                                 + n12 * n21 * n34
                                 + n14 * n22 * n31
                                 - n12 * n24 * n31
                        ) +
                        n44 * (
                                - n13 * n22 * n31
                                 - n11 * n23 * n32
                                 + n11 * n22 * n33
                                 + n13 * n21 * n32
                                 - n12 * n21 * n33
                                 + n12 * n23 * n31
                        )

                );

        }

        transpose() {

                const te = this.elements;
                let tmp;

                tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;
                tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;
                tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;

                tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;
                tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;
                tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;

                return this;

        }

        setPosition( x, y, z ) {

                const te = this.elements;

                if ( x.isVector3 ) {

                        te[ 12 ] = x.x;
                        te[ 13 ] = x.y;
                        te[ 14 ] = x.z;

                } else {

                        te[ 12 ] = x;
                        te[ 13 ] = y;
                        te[ 14 ] = z;

                }

                return this;

        }

        invert() {

                // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
                const te = this.elements,

                        n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ], n41 = te[ 3 ],
                        n12 = te[ 4 ], n22 = te[ 5 ], n32 = te[ 6 ], n42 = te[ 7 ],
                        n13 = te[ 8 ], n23 = te[ 9 ], n33 = te[ 10 ], n43 = te[ 11 ],
                        n14 = te[ 12 ], n24 = te[ 13 ], n34 = te[ 14 ], n44 = te[ 15 ],

                        t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
                        t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
                        t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
                        t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;

                const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;

                if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );

                const detInv = 1 / det;

                te[ 0 ] = t11 * detInv;
                te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;
                te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;
                te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;

                te[ 4 ] = t12 * detInv;
                te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;
                te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;
                te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;

                te[ 8 ] = t13 * detInv;
                te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;
                te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;
                te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;

                te[ 12 ] = t14 * detInv;
                te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;
                te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;
                te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;

                return this;

        }

        scale( v ) {

                const te = this.elements;
                const x = v.x, y = v.y, z = v.z;

                te[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;
                te[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;
                te[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;
                te[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;

                return this;

        }

        getMaxScaleOnAxis() {

                const te = this.elements;

                const scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];
                const scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];
                const scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];

                return Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );

        }

        makeTranslation( x, y, z ) {

                this.set(

                        1, 0, 0, x,
                        0, 1, 0, y,
                        0, 0, 1, z,
                        0, 0, 0, 1

                );

                return this;

        }

        makeRotationX( theta ) {

                const c = Math.cos( theta ), s = Math.sin( theta );

                this.set(

                        1, 0, 0, 0,
                        0, c, - s, 0,
                        0, s, c, 0,
                        0, 0, 0, 1

                );

                return this;

        }

        makeRotationY( theta ) {

                const c = Math.cos( theta ), s = Math.sin( theta );

                this.set(

                         c, 0, s, 0,
                         0, 1, 0, 0,
                        - s, 0, c, 0,
                         0, 0, 0, 1

                );

                return this;

        }

        makeRotationZ( theta ) {

                const c = Math.cos( theta ), s = Math.sin( theta );

                this.set(

                        c, - s, 0, 0,
                        s, c, 0, 0,
                        0, 0, 1, 0,
                        0, 0, 0, 1

                );

                return this;

        }

        makeRotationAxis( axis, angle ) {

                // Based on http://www.gamedev.net/reference/articles/article1199.asp

                const c = Math.cos( angle );
                const s = Math.sin( angle );
                const t = 1 - c;
                const x = axis.x, y = axis.y, z = axis.z;
                const tx = t * x, ty = t * y;

                this.set(

                        tx * x + c, tx * y - s * z, tx * z + s * y, 0,
                        tx * y + s * z, ty * y + c, ty * z - s * x, 0,
                        tx * z - s * y, ty * z + s * x, t * z * z + c, 0,
                        0, 0, 0, 1

                );

                return this;

        }

        makeScale( x, y, z ) {

                this.set(

                        x, 0, 0, 0,
                        0, y, 0, 0,
                        0, 0, z, 0,
                        0, 0, 0, 1

                );

                return this;

        }

        makeShear( x, y, z ) {

                this.set(

                        1, y, z, 0,
                        x, 1, z, 0,
                        x, y, 1, 0,
                        0, 0, 0, 1

                );

                return this;

        }

        compose( position, quaternion, scale ) {

                const te = this.elements;

                const x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
                const x2 = x + x,       y2 = y + y, z2 = z + z;
                const xx = x * x2, xy = x * y2, xz = x * z2;
                const yy = y * y2, yz = y * z2, zz = z * z2;
                const wx = w * x2, wy = w * y2, wz = w * z2;

                const sx = scale.x, sy = scale.y, sz = scale.z;

                te[ 0 ] = ( 1 - ( yy + zz ) ) * sx;
                te[ 1 ] = ( xy + wz ) * sx;
                te[ 2 ] = ( xz - wy ) * sx;
                te[ 3 ] = 0;

                te[ 4 ] = ( xy - wz ) * sy;
                te[ 5 ] = ( 1 - ( xx + zz ) ) * sy;
                te[ 6 ] = ( yz + wx ) * sy;
                te[ 7 ] = 0;

                te[ 8 ] = ( xz + wy ) * sz;
                te[ 9 ] = ( yz - wx ) * sz;
                te[ 10 ] = ( 1 - ( xx + yy ) ) * sz;
                te[ 11 ] = 0;

                te[ 12 ] = position.x;
                te[ 13 ] = position.y;
                te[ 14 ] = position.z;
                te[ 15 ] = 1;

                return this;

        }

        decompose( position, quaternion, scale ) {

                const te = this.elements;

                let sx = _v1$1.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
                const sy = _v1$1.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
                const sz = _v1$1.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();

                // if determine is negative, we need to invert one scale
                const det = this.determinant();
                if ( det < 0 ) sx = - sx;

                position.x = te[ 12 ];
                position.y = te[ 13 ];
                position.z = te[ 14 ];

                // scale the rotation part
                _m1.copy( this );

                const invSX = 1 / sx;
                const invSY = 1 / sy;
                const invSZ = 1 / sz;

                _m1.elements[ 0 ] *= invSX;
                _m1.elements[ 1 ] *= invSX;
                _m1.elements[ 2 ] *= invSX;

                _m1.elements[ 4 ] *= invSY;
                _m1.elements[ 5 ] *= invSY;
                _m1.elements[ 6 ] *= invSY;

                _m1.elements[ 8 ] *= invSZ;
                _m1.elements[ 9 ] *= invSZ;
                _m1.elements[ 10 ] *= invSZ;

                quaternion.setFromRotationMatrix( _m1 );

                scale.x = sx;
                scale.y = sy;
                scale.z = sz;

                return this;

        }

        makePerspective( left, right, top, bottom, near, far ) {

                if ( far === undefined ) {

                        console.warn( 'THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.' );

                }

                const te = this.elements;
                const x = 2 * near / ( right - left );
                const y = 2 * near / ( top - bottom );

                const a = ( right + left ) / ( right - left );
                const b = ( top + bottom ) / ( top - bottom );
                const c = - ( far + near ) / ( far - near );
                const d = - 2 * far * near / ( far - near );

                te[ 0 ] = x;    te[ 4 ] = 0;    te[ 8 ] = a;    te[ 12 ] = 0;
                te[ 1 ] = 0;    te[ 5 ] = y;    te[ 9 ] = b;    te[ 13 ] = 0;
                te[ 2 ] = 0;    te[ 6 ] = 0;    te[ 10 ] = c;   te[ 14 ] = d;
                te[ 3 ] = 0;    te[ 7 ] = 0;    te[ 11 ] = - 1; te[ 15 ] = 0;

                return this;

        }

        makeOrthographic( left, right, top, bottom, near, far ) {

                const te = this.elements;
                const w = 1.0 / ( right - left );
                const h = 1.0 / ( top - bottom );
                const p = 1.0 / ( far - near );

                const x = ( right + left ) * w;
                const y = ( top + bottom ) * h;
                const z = ( far + near ) * p;

                te[ 0 ] = 2 * w;        te[ 4 ] = 0;    te[ 8 ] = 0;    te[ 12 ] = - x;
                te[ 1 ] = 0;    te[ 5 ] = 2 * h;        te[ 9 ] = 0;    te[ 13 ] = - y;
                te[ 2 ] = 0;    te[ 6 ] = 0;    te[ 10 ] = - 2 * p;     te[ 14 ] = - z;
                te[ 3 ] = 0;    te[ 7 ] = 0;    te[ 11 ] = 0;   te[ 15 ] = 1;

                return this;

        }

        equals( matrix ) {

                const te = this.elements;
                const me = matrix.elements;

                for ( let i = 0; i < 16; i ++ ) {

                        if ( te[ i ] !== me[ i ] ) return false;

                }

                return true;

        }

        fromArray( array, offset = 0 ) {

                for ( let i = 0; i < 16; i ++ ) {

                        this.elements[ i ] = array[ i + offset ];

                }

                return this;

        }

        toArray( array = [], offset = 0 ) {

                const te = this.elements;

                array[ offset ] = te[ 0 ];
                array[ offset + 1 ] = te[ 1 ];
                array[ offset + 2 ] = te[ 2 ];
                array[ offset + 3 ] = te[ 3 ];

                array[ offset + 4 ] = te[ 4 ];
                array[ offset + 5 ] = te[ 5 ];
                array[ offset + 6 ] = te[ 6 ];
                array[ offset + 7 ] = te[ 7 ];

                array[ offset + 8 ] = te[ 8 ];
                array[ offset + 9 ] = te[ 9 ];
                array[ offset + 10 ] = te[ 10 ];
                array[ offset + 11 ] = te[ 11 ];

                array[ offset + 12 ] = te[ 12 ];
                array[ offset + 13 ] = te[ 13 ];
                array[ offset + 14 ] = te[ 14 ];
                array[ offset + 15 ] = te[ 15 ];

                return array;

        }

    }

    const _v1$1 = /*@__PURE__*/ new Vector3();
    const _m1 = /*@__PURE__*/ new Matrix4();
    const _zero = /*@__PURE__*/ new Vector3( 0, 0, 0 );
    const _one = /*@__PURE__*/ new Vector3( 1, 1, 1 );
    const _x = /*@__PURE__*/ new Vector3();
    const _y = /*@__PURE__*/ new Vector3();
    const _z = /*@__PURE__*/ new Vector3();

    class Euler {

        constructor( x = 0, y = 0, z = 0, order = Euler.DefaultOrder ) {

                Object.defineProperty( this, 'isEuler', { value: true } );

                this._x = x;
                this._y = y;
                this._z = z;
                this._order = order;

        }

        get x() {

                return this._x;

        }

        set x( value ) {

                this._x = value;
                this._onChangeCallback();

        }

        get y() {

                return this._y;

        }

        set y( value ) {

                this._y = value;
                this._onChangeCallback();

        }

        get z() {

                return this._z;

        }

        set z( value ) {

                this._z = value;
                this._onChangeCallback();

        }

        get order() {

                return this._order;

        }

        set order( value ) {

                this._order = value;
                this._onChangeCallback();

        }

        set( x, y, z, order ) {

                this._x = x;
                this._y = y;
                this._z = z;
                this._order = order || this._order;

                this._onChangeCallback();

                return this;

        }

        clone() {

                return new this.constructor( this._x, this._y, this._z, this._order );

        }

        copy( euler ) {

                this._x = euler._x;
                this._y = euler._y;
                this._z = euler._z;
                this._order = euler._order;

                this._onChangeCallback();

                return this;

        }

        setFromRotationMatrix( m, order, update ) {

                const clamp = MathUtils.clamp;

                // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

                const te = m.elements;
                const m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];
                const m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];
                const m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];

                order = order || this._order;

                switch ( order ) {

                        case 'XYZ':

                                this._y = Math.asin( clamp( m13, - 1, 1 ) );

                                if ( Math.abs( m13 ) < 0.9999999 ) {

                                        this._x = Math.atan2( - m23, m33 );
                                        this._z = Math.atan2( - m12, m11 );

                                } else {

                                        this._x = Math.atan2( m32, m22 );
                                        this._z = 0;

                                }

                                break;

                        case 'YXZ':

                                this._x = Math.asin( - clamp( m23, - 1, 1 ) );

                                if ( Math.abs( m23 ) < 0.9999999 ) {

                                        this._y = Math.atan2( m13, m33 );
                                        this._z = Math.atan2( m21, m22 );

                                } else {

                                        this._y = Math.atan2( - m31, m11 );
                                        this._z = 0;

                                }

                                break;

                        case 'ZXY':

                                this._x = Math.asin( clamp( m32, - 1, 1 ) );

                                if ( Math.abs( m32 ) < 0.9999999 ) {

                                        this._y = Math.atan2( - m31, m33 );
                                        this._z = Math.atan2( - m12, m22 );

                                } else {

                                        this._y = 0;
                                        this._z = Math.atan2( m21, m11 );

                                }

                                break;

                        case 'ZYX':

                                this._y = Math.asin( - clamp( m31, - 1, 1 ) );

                                if ( Math.abs( m31 ) < 0.9999999 ) {

                                        this._x = Math.atan2( m32, m33 );
                                        this._z = Math.atan2( m21, m11 );

                                } else {

                                        this._x = 0;
                                        this._z = Math.atan2( - m12, m22 );

                                }

                                break;

                        case 'YZX':

                                this._z = Math.asin( clamp( m21, - 1, 1 ) );

                                if ( Math.abs( m21 ) < 0.9999999 ) {

                                        this._x = Math.atan2( - m23, m22 );
                                        this._y = Math.atan2( - m31, m11 );

                                } else {

                                        this._x = 0;
                                        this._y = Math.atan2( m13, m33 );

                                }

                                break;

                        case 'XZY':

                                this._z = Math.asin( - clamp( m12, - 1, 1 ) );

                                if ( Math.abs( m12 ) < 0.9999999 ) {

                                        this._x = Math.atan2( m32, m22 );
                                        this._y = Math.atan2( m13, m11 );

                                } else {

                                        this._x = Math.atan2( - m23, m33 );
                                        this._y = 0;

                                }

                                break;

                        default:

                                console.warn( 'THREE.Euler: .setFromRotationMatrix() encountered an unknown order: ' + order );

                }

                this._order = order;

                if ( update !== false ) this._onChangeCallback();

                return this;

        }

        setFromQuaternion( q, order, update ) {

                _matrix.makeRotationFromQuaternion( q );

                return this.setFromRotationMatrix( _matrix, order, update );

        }

        setFromVector3( v, order ) {

                return this.set( v.x, v.y, v.z, order || this._order );

        }

        reorder( newOrder ) {

                // WARNING: this discards revolution information -bhouston

                _quaternion$1.setFromEuler( this );

                return this.setFromQuaternion( _quaternion$1, newOrder );

        }

        equals( euler ) {

                return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );

        }

        fromArray( array ) {

                this._x = array[ 0 ];
                this._y = array[ 1 ];
                this._z = array[ 2 ];
                if ( array[ 3 ] !== undefined ) this._order = array[ 3 ];

                this._onChangeCallback();

                return this;

        }

        toArray( array = [], offset = 0 ) {

                array[ offset ] = this._x;
                array[ offset + 1 ] = this._y;
                array[ offset + 2 ] = this._z;
                array[ offset + 3 ] = this._order;

                return array;

        }

        toVector3( optionalResult ) {

                if ( optionalResult ) {

                        return optionalResult.set( this._x, this._y, this._z );

                } else {

                        return new Vector3( this._x, this._y, this._z );

                }

        }

        _onChange( callback ) {

                this._onChangeCallback = callback;

                return this;

        }

        _onChangeCallback() {}

    }

    Euler.DefaultOrder = 'XYZ';
    Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];

    const _matrix = /*@__PURE__*/ new Matrix4();
    const _quaternion$1 = /*@__PURE__*/ new Quaternion();

    class Layers {

        constructor() {

                this.mask = 1 | 0;

        }

        set( channel ) {

                this.mask = 1 << channel | 0;

        }

        enable( channel ) {

                this.mask |= 1 << channel | 0;

        }

        enableAll() {

                this.mask = 0xffffffff | 0;

        }

        toggle( channel ) {

                this.mask ^= 1 << channel | 0;

        }

        disable( channel ) {

                this.mask &= ~ ( 1 << channel | 0 );

        }

        disableAll() {

                this.mask = 0;

        }

        test( layers ) {

                return ( this.mask & layers.mask ) !== 0;

        }

    }

    let _object3DId = 0;

    const _v1$2 = new Vector3();
    const _q1 = new Quaternion();
    const _m1$1 = new Matrix4();
    const _target = new Vector3();

    const _position = new Vector3();
    const _scale = new Vector3();
    const _quaternion$2 = new Quaternion();

    const _xAxis = new Vector3( 1, 0, 0 );
    const _yAxis = new Vector3( 0, 1, 0 );
    const _zAxis = new Vector3( 0, 0, 1 );

    const _addedEvent = { type: 'added' };
    const _removedEvent = { type: 'removed' };

    function Object3D() {

        Object.defineProperty( this, 'id', { value: _object3DId ++ } );

        this.uuid = MathUtils.generateUUID();

        this.name = '';
        this.type = 'Object3D';

        this.parent = null;
        this.children = [];

        this.up = Object3D.DefaultUp.clone();

        const position = new Vector3();
        const rotation = new Euler();
        const quaternion = new Quaternion();
        const scale = new Vector3( 1, 1, 1 );

        function onRotationChange() {

                quaternion.setFromEuler( rotation, false );

        }

        function onQuaternionChange() {

                rotation.setFromQuaternion( quaternion, undefined, false );

        }

        rotation._onChange( onRotationChange );
        quaternion._onChange( onQuaternionChange );

        Object.defineProperties( this, {
                position: {
                        configurable: true,
                        enumerable: true,
                        value: position
                },
                rotation: {
                        configurable: true,
                        enumerable: true,
                        value: rotation
                },
                quaternion: {
                        configurable: true,
                        enumerable: true,
                        value: quaternion
                },
                scale: {
                        configurable: true,
                        enumerable: true,
                        value: scale
                },
                modelViewMatrix: {
                        value: new Matrix4()
                },
                normalMatrix: {
                        value: new Matrix3()
                }
        } );

        this.matrix = new Matrix4();
        this.matrixWorld = new Matrix4();

        this.matrixAutoUpdate = Object3D.DefaultMatrixAutoUpdate;
        this.matrixWorldNeedsUpdate = false;

        this.layers = new Layers();
        this.visible = true;

        this.castShadow = false;
        this.receiveShadow = false;

        this.frustumCulled = true;
        this.renderOrder = 0;

        this.animations = [];

        this.userData = {};

    }

    Object3D.DefaultUp = new Vector3( 0, 1, 0 );
    Object3D.DefaultMatrixAutoUpdate = true;

    Object3D.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {

        constructor: Object3D,

        isObject3D: true,

        onBeforeRender: function () {},
        onAfterRender: function () {},

        applyMatrix4: function ( matrix ) {

                if ( this.matrixAutoUpdate ) this.updateMatrix();

                this.matrix.premultiply( matrix );

                this.matrix.decompose( this.position, this.quaternion, this.scale );

        },

        applyQuaternion: function ( q ) {

                this.quaternion.premultiply( q );

                return this;

        },

        setRotationFromAxisAngle: function ( axis, angle ) {

                // assumes axis is normalized

                this.quaternion.setFromAxisAngle( axis, angle );

        },

        setRotationFromEuler: function ( euler ) {

                this.quaternion.setFromEuler( euler, true );

        },

        setRotationFromMatrix: function ( m ) {

                // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

                this.quaternion.setFromRotationMatrix( m );

        },

        setRotationFromQuaternion: function ( q ) {

                // assumes q is normalized

                this.quaternion.copy( q );

        },

        rotateOnAxis: function ( axis, angle ) {

                // rotate object on axis in object space
                // axis is assumed to be normalized

                _q1.setFromAxisAngle( axis, angle );

                this.quaternion.multiply( _q1 );

                return this;

        },

        rotateOnWorldAxis: function ( axis, angle ) {

                // rotate object on axis in world space
                // axis is assumed to be normalized
                // method assumes no rotated parent

                _q1.setFromAxisAngle( axis, angle );

                this.quaternion.premultiply( _q1 );

                return this;

        },

        rotateX: function ( angle ) {

                return this.rotateOnAxis( _xAxis, angle );

        },

        rotateY: function ( angle ) {

                return this.rotateOnAxis( _yAxis, angle );

        },

        rotateZ: function ( angle ) {

                return this.rotateOnAxis( _zAxis, angle );

        },

        translateOnAxis: function ( axis, distance ) {

                // translate object by distance along axis in object space
                // axis is assumed to be normalized

                _v1$2.copy( axis ).applyQuaternion( this.quaternion );

                this.position.add( _v1$2.multiplyScalar( distance ) );

                return this;

        },

        translateX: function ( distance ) {

                return this.translateOnAxis( _xAxis, distance );

        },

        translateY: function ( distance ) {

                return this.translateOnAxis( _yAxis, distance );

        },

        translateZ: function ( distance ) {

                return this.translateOnAxis( _zAxis, distance );

        },

        localToWorld: function ( vector ) {

                return vector.applyMatrix4( this.matrixWorld );

        },

        worldToLocal: function ( vector ) {

                return vector.applyMatrix4( _m1$1.copy( this.matrixWorld ).invert() );

        },

        lookAt: function ( x, y, z ) {

                // This method does not support objects having non-uniformly-scaled parent(s)

                if ( x.isVector3 ) {

                        _target.copy( x );

                } else {

                        _target.set( x, y, z );

                }

                const parent = this.parent;

                this.updateWorldMatrix( true, false );

                _position.setFromMatrixPosition( this.matrixWorld );

                if ( this.isCamera || this.isLight ) {

                        _m1$1.lookAt( _position, _target, this.up );

                } else {

                        _m1$1.lookAt( _target, _position, this.up );

                }

                this.quaternion.setFromRotationMatrix( _m1$1 );

                if ( parent ) {

                        _m1$1.extractRotation( parent.matrixWorld );
                        _q1.setFromRotationMatrix( _m1$1 );
                        this.quaternion.premultiply( _q1.invert() );

                }

        },

        add: function ( object ) {

                if ( arguments.length > 1 ) {

                        for ( let i = 0; i < arguments.length; i ++ ) {

                                this.add( arguments[ i ] );

                        }

                        return this;

                }

                if ( object === this ) {

                        console.error( 'THREE.Object3D.add: object can\'t be added as a child of itself.', object );
                        return this;

                }

                if ( object && object.isObject3D ) {

                        if ( object.parent !== null ) {

                                object.parent.remove( object );

                        }

                        object.parent = this;
                        this.children.push( object );

                        object.dispatchEvent( _addedEvent );

                } else {

                        console.error( 'THREE.Object3D.add: object not an instance of THREE.Object3D.', object );

                }

                return this;

        },

        remove: function ( object ) {

                if ( arguments.length > 1 ) {

                        for ( let i = 0; i < arguments.length; i ++ ) {

                                this.remove( arguments[ i ] );

                        }

                        return this;

                }

                const index = this.children.indexOf( object );

                if ( index !== - 1 ) {

                        object.parent = null;
                        this.children.splice( index, 1 );

                        object.dispatchEvent( _removedEvent );

                }

                return this;

        },

        clear: function () {

                for ( let i = 0; i < this.children.length; i ++ ) {

                        const object = this.children[ i ];

                        object.parent = null;

                        object.dispatchEvent( _removedEvent );

                }

                this.children.length = 0;

                return this;


        },

        attach: function ( object ) {

                // adds object as a child of this, while maintaining the object's world transform

                this.updateWorldMatrix( true, false );

                _m1$1.copy( this.matrixWorld ).invert();

                if ( object.parent !== null ) {

                        object.parent.updateWorldMatrix( true, false );

                        _m1$1.multiply( object.parent.matrixWorld );

                }

                object.applyMatrix4( _m1$1 );

                object.updateWorldMatrix( false, false );

                this.add( object );

                return this;

        },

        getObjectById: function ( id ) {

                return this.getObjectByProperty( 'id', id );

        },

        getObjectByName: function ( name ) {

                return this.getObjectByProperty( 'name', name );

        },

        getObjectByProperty: function ( name, value ) {

                if ( this[ name ] === value ) return this;

                for ( let i = 0, l = this.children.length; i < l; i ++ ) {

                        const child = this.children[ i ];
                        const object = child.getObjectByProperty( name, value );

                        if ( object !== undefined ) {

                                return object;

                        }

                }

                return undefined;

        },

        getWorldPosition: function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Object3D: .getWorldPosition() target is now required' );
                        target = new Vector3();

                }

                this.updateWorldMatrix( true, false );

                return target.setFromMatrixPosition( this.matrixWorld );

        },

        getWorldQuaternion: function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Object3D: .getWorldQuaternion() target is now required' );
                        target = new Quaternion();

                }

                this.updateWorldMatrix( true, false );

                this.matrixWorld.decompose( _position, target, _scale );

                return target;

        },

        getWorldScale: function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Object3D: .getWorldScale() target is now required' );
                        target = new Vector3();

                }

                this.updateWorldMatrix( true, false );

                this.matrixWorld.decompose( _position, _quaternion$2, target );

                return target;

        },

        getWorldDirection: function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Object3D: .getWorldDirection() target is now required' );
                        target = new Vector3();

                }

                this.updateWorldMatrix( true, false );

                const e = this.matrixWorld.elements;

                return target.set( e[ 8 ], e[ 9 ], e[ 10 ] ).normalize();

        },

        raycast: function () {},

        traverse: function ( callback ) {

                callback( this );

                const children = this.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        children[ i ].traverse( callback );

                }

        },

        traverseVisible: function ( callback ) {

                if ( this.visible === false ) return;

                callback( this );

                const children = this.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        children[ i ].traverseVisible( callback );

                }

        },

        traverseAncestors: function ( callback ) {

                const parent = this.parent;

                if ( parent !== null ) {

                        callback( parent );

                        parent.traverseAncestors( callback );

                }

        },

        updateMatrix: function () {

                this.matrix.compose( this.position, this.quaternion, this.scale );

                this.matrixWorldNeedsUpdate = true;

        },

        updateMatrixWorld: function ( force ) {

                if ( this.matrixAutoUpdate ) this.updateMatrix();

                if ( this.matrixWorldNeedsUpdate || force ) {

                        if ( this.parent === null ) {

                                this.matrixWorld.copy( this.matrix );

                        } else {

                                this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );

                        }

                        this.matrixWorldNeedsUpdate = false;

                        force = true;

                }

                // update children

                const children = this.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        children[ i ].updateMatrixWorld( force );

                }

        },

        updateWorldMatrix: function ( updateParents, updateChildren ) {

                const parent = this.parent;

                if ( updateParents === true && parent !== null ) {

                        parent.updateWorldMatrix( true, false );

                }

                if ( this.matrixAutoUpdate ) this.updateMatrix();

                if ( this.parent === null ) {

                        this.matrixWorld.copy( this.matrix );

                } else {

                        this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );

                }

                // update children

                if ( updateChildren === true ) {

                        const children = this.children;

                        for ( let i = 0, l = children.length; i < l; i ++ ) {

                                children[ i ].updateWorldMatrix( false, true );

                        }

                }

        },

        toJSON: function ( meta ) {

                // meta is a string when called from JSON.stringify
                const isRootObject = ( meta === undefined || typeof meta === 'string' );

                const output = {};

                // meta is a hash used to collect geometries, materials.
                // not providing it implies that this is the root object
                // being serialized.
                if ( isRootObject ) {

                        // initialize meta obj
                        meta = {
                                geometries: {},
                                materials: {},
                                textures: {},
                                images: {},
                                shapes: {},
                                skeletons: {},
                                animations: {}
                        };

                        output.metadata = {
                                version: 4.5,
                                type: 'Object',
                                generator: 'Object3D.toJSON'
                        };

                }

                // standard Object3D serialization

                const object = {};

                object.uuid = this.uuid;
                object.type = this.type;

                if ( this.name !== '' ) object.name = this.name;
                if ( this.castShadow === true ) object.castShadow = true;
                if ( this.receiveShadow === true ) object.receiveShadow = true;
                if ( this.visible === false ) object.visible = false;
                if ( this.frustumCulled === false ) object.frustumCulled = false;
                if ( this.renderOrder !== 0 ) object.renderOrder = this.renderOrder;
                if ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData;

                object.layers = this.layers.mask;
                object.matrix = this.matrix.toArray();

                if ( this.matrixAutoUpdate === false ) object.matrixAutoUpdate = false;

                // object specific properties

                if ( this.isInstancedMesh ) {

                        object.type = 'InstancedMesh';
                        object.count = this.count;
                        object.instanceMatrix = this.instanceMatrix.toJSON();

                }

                //

                function serialize( library, element ) {

                        if ( library[ element.uuid ] === undefined ) {

                                library[ element.uuid ] = element.toJSON( meta );

                        }

                        return element.uuid;

                }

                if ( this.isMesh || this.isLine || this.isPoints ) {

                        object.geometry = serialize( meta.geometries, this.geometry );

                        const parameters = this.geometry.parameters;

                        if ( parameters !== undefined && parameters.shapes !== undefined ) {

                                const shapes = parameters.shapes;

                                if ( Array.isArray( shapes ) ) {

                                        for ( let i = 0, l = shapes.length; i < l; i ++ ) {

                                                const shape = shapes[ i ];

                                                serialize( meta.shapes, shape );

                                        }

                                } else {

                                        serialize( meta.shapes, shapes );

                                }

                        }

                }

                if ( this.isSkinnedMesh ) {

                        object.bindMode = this.bindMode;
                        object.bindMatrix = this.bindMatrix.toArray();

                        if ( this.skeleton !== undefined ) {

                                serialize( meta.skeletons, this.skeleton );

                                object.skeleton = this.skeleton.uuid;

                        }

                }

                if ( this.material !== undefined ) {

                        if ( Array.isArray( this.material ) ) {

                                const uuids = [];

                                for ( let i = 0, l = this.material.length; i < l; i ++ ) {

                                        uuids.push( serialize( meta.materials, this.material[ i ] ) );

                                }

                                object.material = uuids;

                        } else {

                                object.material = serialize( meta.materials, this.material );

                        }

                }

                //

                if ( this.children.length > 0 ) {

                        object.children = [];

                        for ( let i = 0; i < this.children.length; i ++ ) {

                                object.children.push( this.children[ i ].toJSON( meta ).object );

                        }

                }

                //

                if ( this.animations.length > 0 ) {

                        object.animations = [];

                        for ( let i = 0; i < this.animations.length; i ++ ) {

                                const animation = this.animations[ i ];

                                object.animations.push( serialize( meta.animations, animation ) );

                        }

                }

                if ( isRootObject ) {

                        const geometries = extractFromCache( meta.geometries );
                        const materials = extractFromCache( meta.materials );
                        const textures = extractFromCache( meta.textures );
                        const images = extractFromCache( meta.images );
                        const shapes = extractFromCache( meta.shapes );
                        const skeletons = extractFromCache( meta.skeletons );
                        const animations = extractFromCache( meta.animations );

                        if ( geometries.length > 0 ) output.geometries = geometries;
                        if ( materials.length > 0 ) output.materials = materials;
                        if ( textures.length > 0 ) output.textures = textures;
                        if ( images.length > 0 ) output.images = images;
                        if ( shapes.length > 0 ) output.shapes = shapes;
                        if ( skeletons.length > 0 ) output.skeletons = skeletons;
                        if ( animations.length > 0 ) output.animations = animations;

                }

                output.object = object;

                return output;

                // extract data from the cache hash
                // remove metadata on each item
                // and return as array
                function extractFromCache( cache ) {

                        const values = [];
                        for ( const key in cache ) {

                                const data = cache[ key ];
                                delete data.metadata;
                                values.push( data );

                        }

                        return values;

                }

        },

        clone: function ( recursive ) {

                return new this.constructor().copy( this, recursive );

        },

        copy: function ( source, recursive = true ) {

                this.name = source.name;

                this.up.copy( source.up );

                this.position.copy( source.position );
                this.rotation.order = source.rotation.order;
                this.quaternion.copy( source.quaternion );
                this.scale.copy( source.scale );

                this.matrix.copy( source.matrix );
                this.matrixWorld.copy( source.matrixWorld );

                this.matrixAutoUpdate = source.matrixAutoUpdate;
                this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;

                this.layers.mask = source.layers.mask;
                this.visible = source.visible;

                this.castShadow = source.castShadow;
                this.receiveShadow = source.receiveShadow;

                this.frustumCulled = source.frustumCulled;
                this.renderOrder = source.renderOrder;

                this.userData = JSON.parse( JSON.stringify( source.userData ) );

                if ( recursive === true ) {

                        for ( let i = 0; i < source.children.length; i ++ ) {

                                const child = source.children[ i ];
                                this.add( child.clone() );

                        }

                }

                return this;

        }

    } );

    const _vector1 = /*@__PURE__*/ new Vector3();
    const _vector2 = /*@__PURE__*/ new Vector3();
    const _normalMatrix = /*@__PURE__*/ new Matrix3();

    class Plane {

        constructor( normal, constant ) {

                Object.defineProperty( this, 'isPlane', { value: true } );

                // normal is assumed to be normalized

                this.normal = ( normal !== undefined ) ? normal : new Vector3( 1, 0, 0 );
                this.constant = ( constant !== undefined ) ? constant : 0;

        }

        set( normal, constant ) {

                this.normal.copy( normal );
                this.constant = constant;

                return this;

        }

        setComponents( x, y, z, w ) {

                this.normal.set( x, y, z );
                this.constant = w;

                return this;

        }

        setFromNormalAndCoplanarPoint( normal, point ) {

                this.normal.copy( normal );
                this.constant = - point.dot( this.normal );

                return this;

        }

        setFromCoplanarPoints( a, b, c ) {

                const normal = _vector1.subVectors( c, b ).cross( _vector2.subVectors( a, b ) ).normalize();

                // Q: should an error be thrown if normal is zero (e.g. degenerate plane)?

                this.setFromNormalAndCoplanarPoint( normal, a );

                return this;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( plane ) {

                this.normal.copy( plane.normal );
                this.constant = plane.constant;

                return this;

        }

        normalize() {

                // Note: will lead to a divide by zero if the plane is invalid.

                const inverseNormalLength = 1.0 / this.normal.length();
                this.normal.multiplyScalar( inverseNormalLength );
                this.constant *= inverseNormalLength;

                return this;

        }

        negate() {

                this.constant *= - 1;
                this.normal.negate();

                return this;

        }

        distanceToPoint( point ) {

                return this.normal.dot( point ) + this.constant;

        }

        distanceToSphere( sphere ) {

                return this.distanceToPoint( sphere.center ) - sphere.radius;

        }

        projectPoint( point, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Plane: .projectPoint() target is now required' );
                        target = new Vector3();

                }

                return target.copy( this.normal ).multiplyScalar( - this.distanceToPoint( point ) ).add( point );

        }

        intersectLine( line, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Plane: .intersectLine() target is now required' );
                        target = new Vector3();

                }

                const direction = line.delta( _vector1 );

                const denominator = this.normal.dot( direction );

                if ( denominator === 0 ) {

                        // line is coplanar, return origin
                        if ( this.distanceToPoint( line.start ) === 0 ) {

                                return target.copy( line.start );

                        }

                        // Unsure if this is the correct method to handle this case.
                        return undefined;

                }

                const t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;

                if ( t < 0 || t > 1 ) {

                        return undefined;

                }

                return target.copy( direction ).multiplyScalar( t ).add( line.start );

        }

        intersectsLine( line ) {

                // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.

                const startSign = this.distanceToPoint( line.start );
                const endSign = this.distanceToPoint( line.end );

                return ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 );

        }

        intersectsBox( box ) {

                return box.intersectsPlane( this );

        }

        intersectsSphere( sphere ) {

                return sphere.intersectsPlane( this );

        }

        coplanarPoint( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Plane: .coplanarPoint() target is now required' );
                        target = new Vector3();

                }

                return target.copy( this.normal ).multiplyScalar( - this.constant );

        }

        applyMatrix4( matrix, optionalNormalMatrix ) {

                const normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix( matrix );

                const referencePoint = this.coplanarPoint( _vector1 ).applyMatrix4( matrix );

                const normal = this.normal.applyMatrix3( normalMatrix ).normalize();

                this.constant = - referencePoint.dot( normal );

                return this;

        }

        translate( offset ) {

                this.constant -= offset.dot( this.normal );

                return this;

        }

        equals( plane ) {

                return plane.normal.equals( this.normal ) && ( plane.constant === this.constant );

        }

    }

    const _v0$1 = /*@__PURE__*/ new Vector3();
    const _v1$3 = /*@__PURE__*/ new Vector3();
    const _v2$1 = /*@__PURE__*/ new Vector3();
    const _v3 = /*@__PURE__*/ new Vector3();

    const _vab = /*@__PURE__*/ new Vector3();
    const _vac = /*@__PURE__*/ new Vector3();
    const _vbc = /*@__PURE__*/ new Vector3();
    const _vap = /*@__PURE__*/ new Vector3();
    const _vbp = /*@__PURE__*/ new Vector3();
    const _vcp = /*@__PURE__*/ new Vector3();

    class Triangle {

        constructor( a, b, c ) {

                this.a = ( a !== undefined ) ? a : new Vector3();
                this.b = ( b !== undefined ) ? b : new Vector3();
                this.c = ( c !== undefined ) ? c : new Vector3();

        }

        static getNormal( a, b, c, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Triangle: .getNormal() target is now required' );
                        target = new Vector3();

                }

                target.subVectors( c, b );
                _v0$1.subVectors( a, b );
                target.cross( _v0$1 );

                const targetLengthSq = target.lengthSq();
                if ( targetLengthSq > 0 ) {

                        return target.multiplyScalar( 1 / Math.sqrt( targetLengthSq ) );

                }

                return target.set( 0, 0, 0 );

        }

        // static/instance method to calculate barycentric coordinates
        // based on: http://www.blackpawn.com/texts/pointinpoly/default.html
        static getBarycoord( point, a, b, c, target ) {

                _v0$1.subVectors( c, a );
                _v1$3.subVectors( b, a );
                _v2$1.subVectors( point, a );

                const dot00 = _v0$1.dot( _v0$1 );
                const dot01 = _v0$1.dot( _v1$3 );
                const dot02 = _v0$1.dot( _v2$1 );
                const dot11 = _v1$3.dot( _v1$3 );
                const dot12 = _v1$3.dot( _v2$1 );

                const denom = ( dot00 * dot11 - dot01 * dot01 );

                if ( target === undefined ) {

                        console.warn( 'THREE.Triangle: .getBarycoord() target is now required' );
                        target = new Vector3();

                }

                // collinear or singular triangle
                if ( denom === 0 ) {

                        // arbitrary location outside of triangle?
                        // not sure if this is the best idea, maybe should be returning undefined
                        return target.set( - 2, - 1, - 1 );

                }

                const invDenom = 1 / denom;
                const u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;
                const v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;

                // barycentric coordinates must always sum to 1
                return target.set( 1 - u - v, v, u );

        }

        static containsPoint( point, a, b, c ) {

                this.getBarycoord( point, a, b, c, _v3 );

                return ( _v3.x >= 0 ) && ( _v3.y >= 0 ) && ( ( _v3.x + _v3.y ) <= 1 );

        }

        static getUV( point, p1, p2, p3, uv1, uv2, uv3, target ) {

                this.getBarycoord( point, p1, p2, p3, _v3 );

                target.set( 0, 0 );
                target.addScaledVector( uv1, _v3.x );
                target.addScaledVector( uv2, _v3.y );
                target.addScaledVector( uv3, _v3.z );

                return target;

        }

        static isFrontFacing( a, b, c, direction ) {

                _v0$1.subVectors( c, b );
                _v1$3.subVectors( a, b );

                // strictly front facing
                return ( _v0$1.cross( _v1$3 ).dot( direction ) < 0 ) ? true : false;

        }

        set( a, b, c ) {

                this.a.copy( a );
                this.b.copy( b );
                this.c.copy( c );

                return this;

        }

        setFromPointsAndIndices( points, i0, i1, i2 ) {

                this.a.copy( points[ i0 ] );
                this.b.copy( points[ i1 ] );
                this.c.copy( points[ i2 ] );

                return this;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( triangle ) {

                this.a.copy( triangle.a );
                this.b.copy( triangle.b );
                this.c.copy( triangle.c );

                return this;

        }

        getArea() {

                _v0$1.subVectors( this.c, this.b );
                _v1$3.subVectors( this.a, this.b );

                return _v0$1.cross( _v1$3 ).length() * 0.5;

        }

        getMidpoint( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Triangle: .getMidpoint() target is now required' );
                        target = new Vector3();

                }

                return target.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );

        }

        getNormal( target ) {

                return Triangle.getNormal( this.a, this.b, this.c, target );

        }

        getPlane( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Triangle: .getPlane() target is now required' );
                        target = new Plane();

                }

                return target.setFromCoplanarPoints( this.a, this.b, this.c );

        }

        getBarycoord( point, target ) {

                return Triangle.getBarycoord( point, this.a, this.b, this.c, target );

        }

        getUV( point, uv1, uv2, uv3, target ) {

                return Triangle.getUV( point, this.a, this.b, this.c, uv1, uv2, uv3, target );

        }

        containsPoint( point ) {

                return Triangle.containsPoint( point, this.a, this.b, this.c );

        }

        isFrontFacing( direction ) {

                return Triangle.isFrontFacing( this.a, this.b, this.c, direction );

        }

        intersectsBox( box ) {

                return box.intersectsTriangle( this );

        }

        closestPointToPoint( p, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Triangle: .closestPointToPoint() target is now required' );
                        target = new Vector3();

                }

                const a = this.a, b = this.b, c = this.c;
                let v, w;

                // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
                // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
                // under the accompanying license; see chapter 5.1.5 for detailed explanation.
                // basically, we're distinguishing which of the voronoi regions of the triangle
                // the point lies in with the minimum amount of redundant computation.

                _vab.subVectors( b, a );
                _vac.subVectors( c, a );
                _vap.subVectors( p, a );
                const d1 = _vab.dot( _vap );
                const d2 = _vac.dot( _vap );
                if ( d1 <= 0 && d2 <= 0 ) {

                        // vertex region of A; barycentric coords (1, 0, 0)
                        return target.copy( a );

                }

                _vbp.subVectors( p, b );
                const d3 = _vab.dot( _vbp );
                const d4 = _vac.dot( _vbp );
                if ( d3 >= 0 && d4 <= d3 ) {

                        // vertex region of B; barycentric coords (0, 1, 0)
                        return target.copy( b );

                }

                const vc = d1 * d4 - d3 * d2;
                if ( vc <= 0 && d1 >= 0 && d3 <= 0 ) {

                        v = d1 / ( d1 - d3 );
                        // edge region of AB; barycentric coords (1-v, v, 0)
                        return target.copy( a ).addScaledVector( _vab, v );

                }

                _vcp.subVectors( p, c );
                const d5 = _vab.dot( _vcp );
                const d6 = _vac.dot( _vcp );
                if ( d6 >= 0 && d5 <= d6 ) {

                        // vertex region of C; barycentric coords (0, 0, 1)
                        return target.copy( c );

                }

                const vb = d5 * d2 - d1 * d6;
                if ( vb <= 0 && d2 >= 0 && d6 <= 0 ) {

                        w = d2 / ( d2 - d6 );
                        // edge region of AC; barycentric coords (1-w, 0, w)
                        return target.copy( a ).addScaledVector( _vac, w );

                }

                const va = d3 * d6 - d5 * d4;
                if ( va <= 0 && ( d4 - d3 ) >= 0 && ( d5 - d6 ) >= 0 ) {

                        _vbc.subVectors( c, b );
                        w = ( d4 - d3 ) / ( ( d4 - d3 ) + ( d5 - d6 ) );
                        // edge region of BC; barycentric coords (0, 1-w, w)
                        return target.copy( b ).addScaledVector( _vbc, w ); // edge region of BC

                }

                // face region
                const denom = 1 / ( va + vb + vc );
                // u = va * denom
                v = vb * denom;
                w = vc * denom;

                return target.copy( a ).addScaledVector( _vab, v ).addScaledVector( _vac, w );

        }

        equals( triangle ) {

                return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );

        }

    }

    const _colorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,
        'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,
        'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,
        'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,
        'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,
        'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,
        'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,
        'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,
        'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,
        'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,
        'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,
        'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,
        'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,
        'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,
        'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,
        'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,
        'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,
        'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,
        'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,
        'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,
        'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,
        'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,
        'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,
        'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };

    const _hslA = { h: 0, s: 0, l: 0 };
    const _hslB = { h: 0, s: 0, l: 0 };

    function hue2rgb( p, q, t ) {

        if ( t < 0 ) t += 1;
        if ( t > 1 ) t -= 1;
        if ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;
        if ( t < 1 / 2 ) return q;
        if ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );
        return p;

    }

    function SRGBToLinear( c ) {

        return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );

    }

    function LinearToSRGB( c ) {

        return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;

    }

    class Color {

        constructor( r, g, b ) {

                Object.defineProperty( this, 'isColor', { value: true } );

                if ( g === undefined && b === undefined ) {

                        // r is THREE.Color, hex or string
                        return this.set( r );

                }

                return this.setRGB( r, g, b );

        }

        set( value ) {

                if ( value && value.isColor ) {

                        this.copy( value );

                } else if ( typeof value === 'number' ) {

                        this.setHex( value );

                } else if ( typeof value === 'string' ) {

                        this.setStyle( value );

                }

                return this;

        }

        setScalar( scalar ) {

                this.r = scalar;
                this.g = scalar;
                this.b = scalar;

                return this;

        }

        setHex( hex ) {

                hex = Math.floor( hex );

                this.r = ( hex >> 16 & 255 ) / 255;
                this.g = ( hex >> 8 & 255 ) / 255;
                this.b = ( hex & 255 ) / 255;

                return this;

        }

        setRGB( r, g, b ) {

                this.r = r;
                this.g = g;
                this.b = b;

                return this;

        }

        setHSL( h, s, l ) {

                // h,s,l ranges are in 0.0 - 1.0
                h = MathUtils.euclideanModulo( h, 1 );
                s = MathUtils.clamp( s, 0, 1 );
                l = MathUtils.clamp( l, 0, 1 );

                if ( s === 0 ) {

                        this.r = this.g = this.b = l;

                } else {

                        const p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );
                        const q = ( 2 * l ) - p;

                        this.r = hue2rgb( q, p, h + 1 / 3 );
                        this.g = hue2rgb( q, p, h );
                        this.b = hue2rgb( q, p, h - 1 / 3 );

                }

                return this;

        }

        setStyle( style ) {

                function handleAlpha( string ) {

                        if ( string === undefined ) return;

                        if ( parseFloat( string ) < 1 ) {

                                console.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );

                        }

                }


                let m;

                if ( m = /^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec( style ) ) {

                        // rgb / hsl

                        let color;
                        const name = m[ 1 ];
                        const components = m[ 2 ];

                        switch ( name ) {

                                case 'rgb':
                                case 'rgba':

                                        if ( color = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec( components ) ) {

                                                // rgb(255,0,0) rgba(255,0,0,0.5)
                                                this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;
                                                this.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255;
                                                this.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255;

                                                handleAlpha( color[ 4 ] );

                                                return this;

                                        }

                                        if ( color = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec( components ) ) {

                                                // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
                                                this.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100;
                                                this.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100;
                                                this.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100;

                                                handleAlpha( color[ 4 ] );

                                                return this;

                                        }

                                        break;

                                case 'hsl':
                                case 'hsla':

                                        if ( color = /^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec( components ) ) {

                                                // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
                                                const h = parseFloat( color[ 1 ] ) / 360;
                                                const s = parseInt( color[ 2 ], 10 ) / 100;
                                                const l = parseInt( color[ 3 ], 10 ) / 100;

                                                handleAlpha( color[ 4 ] );

                                                return this.setHSL( h, s, l );

                                        }

                                        break;

                        }

                } else if ( m = /^\#([A-Fa-f\d]+)$/.exec( style ) ) {

                        // hex color

                        const hex = m[ 1 ];
                        const size = hex.length;

                        if ( size === 3 ) {

                                // #ff0
                                this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255;
                                this.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255;
                                this.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255;

                                return this;

                        } else if ( size === 6 ) {

                                // #ff0000
                                this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255;
                                this.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255;
                                this.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255;

                                return this;

                        }

                }

                if ( style && style.length > 0 ) {

                        return this.setColorName( style );

                }

                return this;

        }

        setColorName( style ) {

                // color keywords
                const hex = _colorKeywords[ style ];

                if ( hex !== undefined ) {

                        // red
                        this.setHex( hex );

                } else {

                        // unknown color
                        console.warn( 'THREE.Color: Unknown color ' + style );

                }

                return this;

        }

        clone() {

                return new this.constructor( this.r, this.g, this.b );

        }

        copy( color ) {

                this.r = color.r;
                this.g = color.g;
                this.b = color.b;

                return this;

        }

        copyGammaToLinear( color, gammaFactor = 2.0 ) {

                this.r = Math.pow( color.r, gammaFactor );
                this.g = Math.pow( color.g, gammaFactor );
                this.b = Math.pow( color.b, gammaFactor );

                return this;

        }

        copyLinearToGamma( color, gammaFactor = 2.0 ) {

                const safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0;

                this.r = Math.pow( color.r, safeInverse );
                this.g = Math.pow( color.g, safeInverse );
                this.b = Math.pow( color.b, safeInverse );

                return this;

        }

        convertGammaToLinear( gammaFactor ) {

                this.copyGammaToLinear( this, gammaFactor );

                return this;

        }

        convertLinearToGamma( gammaFactor ) {

                this.copyLinearToGamma( this, gammaFactor );

                return this;

        }

        copySRGBToLinear( color ) {

                this.r = SRGBToLinear( color.r );
                this.g = SRGBToLinear( color.g );
                this.b = SRGBToLinear( color.b );

                return this;

        }

        copyLinearToSRGB( color ) {

                this.r = LinearToSRGB( color.r );
                this.g = LinearToSRGB( color.g );
                this.b = LinearToSRGB( color.b );

                return this;

        }

        convertSRGBToLinear() {

                this.copySRGBToLinear( this );

                return this;

        }

        convertLinearToSRGB() {

                this.copyLinearToSRGB( this );

                return this;

        }

        getHex() {

                return ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0;

        }

        getHexString() {

                return ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );

        }

        getHSL( target ) {

                // h,s,l ranges are in 0.0 - 1.0

                if ( target === undefined ) {

                        console.warn( 'THREE.Color: .getHSL() target is now required' );
                        target = { h: 0, s: 0, l: 0 };

                }

                const r = this.r, g = this.g, b = this.b;

                const max = Math.max( r, g, b );
                const min = Math.min( r, g, b );

                let hue, saturation;
                const lightness = ( min + max ) / 2.0;

                if ( min === max ) {

                        hue = 0;
                        saturation = 0;

                } else {

                        const delta = max - min;

                        saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );

                        switch ( max ) {

                                case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;
                                case g: hue = ( b - r ) / delta + 2; break;
                                case b: hue = ( r - g ) / delta + 4; break;

                        }

                        hue /= 6;

                }

                target.h = hue;
                target.s = saturation;
                target.l = lightness;

                return target;

        }

        getStyle() {

                return 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')';

        }

        offsetHSL( h, s, l ) {

                this.getHSL( _hslA );

                _hslA.h += h; _hslA.s += s; _hslA.l += l;

                this.setHSL( _hslA.h, _hslA.s, _hslA.l );

                return this;

        }

        add( color ) {

                this.r += color.r;
                this.g += color.g;
                this.b += color.b;

                return this;

        }

        addColors( color1, color2 ) {

                this.r = color1.r + color2.r;
                this.g = color1.g + color2.g;
                this.b = color1.b + color2.b;

                return this;

        }

        addScalar( s ) {

                this.r += s;
                this.g += s;
                this.b += s;

                return this;

        }

        sub( color ) {

                this.r = Math.max( 0, this.r - color.r );
                this.g = Math.max( 0, this.g - color.g );
                this.b = Math.max( 0, this.b - color.b );

                return this;

        }

        multiply( color ) {

                this.r *= color.r;
                this.g *= color.g;
                this.b *= color.b;

                return this;

        }

        multiplyScalar( s ) {

                this.r *= s;
                this.g *= s;
                this.b *= s;

                return this;

        }

        lerp( color, alpha ) {

                this.r += ( color.r - this.r ) * alpha;
                this.g += ( color.g - this.g ) * alpha;
                this.b += ( color.b - this.b ) * alpha;

                return this;

        }

        lerpColors( color1, color2, alpha ) {

                this.r = color1.r + ( color2.r - color1.r ) * alpha;
                this.g = color1.g + ( color2.g - color1.g ) * alpha;
                this.b = color1.b + ( color2.b - color1.b ) * alpha;

                return this;

        }

        lerpHSL( color, alpha ) {

                this.getHSL( _hslA );
                color.getHSL( _hslB );

                const h = MathUtils.lerp( _hslA.h, _hslB.h, alpha );
                const s = MathUtils.lerp( _hslA.s, _hslB.s, alpha );
                const l = MathUtils.lerp( _hslA.l, _hslB.l, alpha );

                this.setHSL( h, s, l );

                return this;

        }

        equals( c ) {

                return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );

        }

        fromArray( array, offset = 0 ) {

                this.r = array[ offset ];
                this.g = array[ offset + 1 ];
                this.b = array[ offset + 2 ];

                return this;

        }

        toArray( array = [], offset = 0 ) {

                array[ offset ] = this.r;
                array[ offset + 1 ] = this.g;
                array[ offset + 2 ] = this.b;

                return array;

        }

        fromBufferAttribute( attribute, index ) {

                this.r = attribute.getX( index );
                this.g = attribute.getY( index );
                this.b = attribute.getZ( index );

                if ( attribute.normalized === true ) {

                        // assuming Uint8Array

                        this.r /= 255;
                        this.g /= 255;
                        this.b /= 255;

                }

                return this;

        }

        toJSON() {

                return this.getHex();

        }

    }

    Color.NAMES = _colorKeywords;
    Color.prototype.r = 1;
    Color.prototype.g = 1;
    Color.prototype.b = 1;

    class Face3 {

        constructor( a, b, c, normal, color, materialIndex = 0 ) {

                this.a = a;
                this.b = b;
                this.c = c;

                this.normal = ( normal && normal.isVector3 ) ? normal : new Vector3();
                this.vertexNormals = Array.isArray( normal ) ? normal : [];

                this.color = ( color && color.isColor ) ? color : new Color();
                this.vertexColors = Array.isArray( color ) ? color : [];

                this.materialIndex = materialIndex;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( source ) {

                this.a = source.a;
                this.b = source.b;
                this.c = source.c;

                this.normal.copy( source.normal );
                this.color.copy( source.color );

                this.materialIndex = source.materialIndex;

                for ( let i = 0, il = source.vertexNormals.length; i < il; i ++ ) {

                        this.vertexNormals[ i ] = source.vertexNormals[ i ].clone();

                }

                for ( let i = 0, il = source.vertexColors.length; i < il; i ++ ) {

                        this.vertexColors[ i ] = source.vertexColors[ i ].clone();

                }

                return this;

        }

    }

    let materialId = 0;

    function Material() {

        Object.defineProperty( this, 'id', { value: materialId ++ } );

        this.uuid = MathUtils.generateUUID();

        this.name = '';
        this.type = 'Material';

        this.fog = true;

        this.blending = NormalBlending;
        this.side = FrontSide;
        this.flatShading = false;
        this.vertexColors = false;

        this.opacity = 1;
        this.transparent = false;

        this.blendSrc = SrcAlphaFactor;
        this.blendDst = OneMinusSrcAlphaFactor;
        this.blendEquation = AddEquation;
        this.blendSrcAlpha = null;
        this.blendDstAlpha = null;
        this.blendEquationAlpha = null;

        this.depthFunc = LessEqualDepth;
        this.depthTest = true;
        this.depthWrite = true;

        this.stencilWriteMask = 0xff;
        this.stencilFunc = AlwaysStencilFunc;
        this.stencilRef = 0;
        this.stencilFuncMask = 0xff;
        this.stencilFail = KeepStencilOp;
        this.stencilZFail = KeepStencilOp;
        this.stencilZPass = KeepStencilOp;
        this.stencilWrite = false;

        this.clippingPlanes = null;
        this.clipIntersection = false;
        this.clipShadows = false;

        this.shadowSide = null;

        this.colorWrite = true;

        this.precision = null; // override the renderer's default precision for this material

        this.polygonOffset = false;
        this.polygonOffsetFactor = 0;
        this.polygonOffsetUnits = 0;

        this.dithering = false;

        this.alphaTest = 0;
        this.premultipliedAlpha = false;

        this.visible = true;

        this.toneMapped = true;

        this.userData = {};

        this.version = 0;

    }

    Material.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {

        constructor: Material,

        isMaterial: true,

        onBeforeCompile: function ( /* shaderobject, renderer */ ) {},

        customProgramCacheKey: function () {

                return this.onBeforeCompile.toString();

        },

        setValues: function ( values ) {

                if ( values === undefined ) return;

                for ( const key in values ) {

                        const newValue = values[ key ];

                        if ( newValue === undefined ) {

                                console.warn( 'THREE.Material: \'' + key + '\' parameter is undefined.' );
                                continue;

                        }

                        // for backward compatability if shading is set in the constructor
                        if ( key === 'shading' ) {

                                console.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );
                                this.flatShading = ( newValue === FlatShading ) ? true : false;
                                continue;

                        }

                        const currentValue = this[ key ];

                        if ( currentValue === undefined ) {

                                console.warn( 'THREE.' + this.type + ': \'' + key + '\' is not a property of this material.' );
                                continue;

                        }

                        if ( currentValue && currentValue.isColor ) {

                                currentValue.set( newValue );

                        } else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) {

                                currentValue.copy( newValue );

                        } else {

                                this[ key ] = newValue;

                        }

                }

        },

        toJSON: function ( meta ) {

                const isRoot = ( meta === undefined || typeof meta === 'string' );

                if ( isRoot ) {

                        meta = {
                                textures: {},
                                images: {}
                        };

                }

                const data = {
                        metadata: {
                                version: 4.5,
                                type: 'Material',
                                generator: 'Material.toJSON'
                        }
                };

                // standard Material serialization
                data.uuid = this.uuid;
                data.type = this.type;

                if ( this.name !== '' ) data.name = this.name;

                if ( this.color && this.color.isColor ) data.color = this.color.getHex();

                if ( this.roughness !== undefined ) data.roughness = this.roughness;
                if ( this.metalness !== undefined ) data.metalness = this.metalness;

                if ( this.sheen && this.sheen.isColor ) data.sheen = this.sheen.getHex();
                if ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex();
                if ( this.emissiveIntensity && this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity;

                if ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex();
                if ( this.shininess !== undefined ) data.shininess = this.shininess;
                if ( this.clearcoat !== undefined ) data.clearcoat = this.clearcoat;
                if ( this.clearcoatRoughness !== undefined ) data.clearcoatRoughness = this.clearcoatRoughness;

                if ( this.clearcoatMap && this.clearcoatMap.isTexture ) {

                        data.clearcoatMap = this.clearcoatMap.toJSON( meta ).uuid;

                }

                if ( this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture ) {

                        data.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON( meta ).uuid;

                }

                if ( this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture ) {

                        data.clearcoatNormalMap = this.clearcoatNormalMap.toJSON( meta ).uuid;
                        data.clearcoatNormalScale = this.clearcoatNormalScale.toArray();

                }

                if ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;
                if ( this.matcap && this.matcap.isTexture ) data.matcap = this.matcap.toJSON( meta ).uuid;
                if ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;
                if ( this.lightMap && this.lightMap.isTexture ) data.lightMap = this.lightMap.toJSON( meta ).uuid;

                if ( this.aoMap && this.aoMap.isTexture ) {

                        data.aoMap = this.aoMap.toJSON( meta ).uuid;
                        data.aoMapIntensity = this.aoMapIntensity;

                }

                if ( this.bumpMap && this.bumpMap.isTexture ) {

                        data.bumpMap = this.bumpMap.toJSON( meta ).uuid;
                        data.bumpScale = this.bumpScale;

                }

                if ( this.normalMap && this.normalMap.isTexture ) {

                        data.normalMap = this.normalMap.toJSON( meta ).uuid;
                        data.normalMapType = this.normalMapType;
                        data.normalScale = this.normalScale.toArray();

                }

                if ( this.displacementMap && this.displacementMap.isTexture ) {

                        data.displacementMap = this.displacementMap.toJSON( meta ).uuid;
                        data.displacementScale = this.displacementScale;
                        data.displacementBias = this.displacementBias;

                }

                if ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;
                if ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;

                if ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;
                if ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;

                if ( this.envMap && this.envMap.isTexture ) {

                        data.envMap = this.envMap.toJSON( meta ).uuid;
                        data.reflectivity = this.reflectivity; // Scale behind envMap
                        data.refractionRatio = this.refractionRatio;

                        if ( this.combine !== undefined ) data.combine = this.combine;
                        if ( this.envMapIntensity !== undefined ) data.envMapIntensity = this.envMapIntensity;

                }

                if ( this.gradientMap && this.gradientMap.isTexture ) {

                        data.gradientMap = this.gradientMap.toJSON( meta ).uuid;

                }

                if ( this.size !== undefined ) data.size = this.size;
                if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;

                if ( this.blending !== NormalBlending ) data.blending = this.blending;
                if ( this.flatShading === true ) data.flatShading = this.flatShading;
                if ( this.side !== FrontSide ) data.side = this.side;
                if ( this.vertexColors ) data.vertexColors = true;

                if ( this.opacity < 1 ) data.opacity = this.opacity;
                if ( this.transparent === true ) data.transparent = this.transparent;

                data.depthFunc = this.depthFunc;
                data.depthTest = this.depthTest;
                data.depthWrite = this.depthWrite;

                data.stencilWrite = this.stencilWrite;
                data.stencilWriteMask = this.stencilWriteMask;
                data.stencilFunc = this.stencilFunc;
                data.stencilRef = this.stencilRef;
                data.stencilFuncMask = this.stencilFuncMask;
                data.stencilFail = this.stencilFail;
                data.stencilZFail = this.stencilZFail;
                data.stencilZPass = this.stencilZPass;

                // rotation (SpriteMaterial)
                if ( this.rotation && this.rotation !== 0 ) data.rotation = this.rotation;

                if ( this.polygonOffset === true ) data.polygonOffset = true;
                if ( this.polygonOffsetFactor !== 0 ) data.polygonOffsetFactor = this.polygonOffsetFactor;
                if ( this.polygonOffsetUnits !== 0 ) data.polygonOffsetUnits = this.polygonOffsetUnits;

                if ( this.linewidth && this.linewidth !== 1 ) data.linewidth = this.linewidth;
                if ( this.dashSize !== undefined ) data.dashSize = this.dashSize;
                if ( this.gapSize !== undefined ) data.gapSize = this.gapSize;
                if ( this.scale !== undefined ) data.scale = this.scale;

                if ( this.dithering === true ) data.dithering = true;

                if ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest;
                if ( this.premultipliedAlpha === true ) data.premultipliedAlpha = this.premultipliedAlpha;

                if ( this.wireframe === true ) data.wireframe = this.wireframe;
                if ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth;
                if ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap;
                if ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin;

                if ( this.morphTargets === true ) data.morphTargets = true;
                if ( this.morphNormals === true ) data.morphNormals = true;
                if ( this.skinning === true ) data.skinning = true;

                if ( this.visible === false ) data.visible = false;

                if ( this.toneMapped === false ) data.toneMapped = false;

                if ( JSON.stringify( this.userData ) !== '{}' ) data.userData = this.userData;

                // TODO: Copied from Object3D.toJSON

                function extractFromCache( cache ) {

                        const values = [];

                        for ( const key in cache ) {

                                const data = cache[ key ];
                                delete data.metadata;
                                values.push( data );

                        }

                        return values;

                }

                if ( isRoot ) {

                        const textures = extractFromCache( meta.textures );
                        const images = extractFromCache( meta.images );

                        if ( textures.length > 0 ) data.textures = textures;
                        if ( images.length > 0 ) data.images = images;

                }

                return data;

        },

        clone: function () {

                return new this.constructor().copy( this );

        },

        copy: function ( source ) {

                this.name = source.name;

                this.fog = source.fog;

                this.blending = source.blending;
                this.side = source.side;
                this.flatShading = source.flatShading;
                this.vertexColors = source.vertexColors;

                this.opacity = source.opacity;
                this.transparent = source.transparent;

                this.blendSrc = source.blendSrc;
                this.blendDst = source.blendDst;
                this.blendEquation = source.blendEquation;
                this.blendSrcAlpha = source.blendSrcAlpha;
                this.blendDstAlpha = source.blendDstAlpha;
                this.blendEquationAlpha = source.blendEquationAlpha;

                this.depthFunc = source.depthFunc;
                this.depthTest = source.depthTest;
                this.depthWrite = source.depthWrite;

                this.stencilWriteMask = source.stencilWriteMask;
                this.stencilFunc = source.stencilFunc;
                this.stencilRef = source.stencilRef;
                this.stencilFuncMask = source.stencilFuncMask;
                this.stencilFail = source.stencilFail;
                this.stencilZFail = source.stencilZFail;
                this.stencilZPass = source.stencilZPass;
                this.stencilWrite = source.stencilWrite;

                const srcPlanes = source.clippingPlanes;
                let dstPlanes = null;

                if ( srcPlanes !== null ) {

                        const n = srcPlanes.length;
                        dstPlanes = new Array( n );

                        for ( let i = 0; i !== n; ++ i ) {

                                dstPlanes[ i ] = srcPlanes[ i ].clone();

                        }

                }

                this.clippingPlanes = dstPlanes;
                this.clipIntersection = source.clipIntersection;
                this.clipShadows = source.clipShadows;

                this.shadowSide = source.shadowSide;

                this.colorWrite = source.colorWrite;

                this.precision = source.precision;

                this.polygonOffset = source.polygonOffset;
                this.polygonOffsetFactor = source.polygonOffsetFactor;
                this.polygonOffsetUnits = source.polygonOffsetUnits;

                this.dithering = source.dithering;

                this.alphaTest = source.alphaTest;
                this.premultipliedAlpha = source.premultipliedAlpha;

                this.visible = source.visible;

                this.toneMapped = source.toneMapped;

                this.userData = JSON.parse( JSON.stringify( source.userData ) );

                return this;

        },

        dispose: function () {

                this.dispatchEvent( { type: 'dispose' } );

        }

    } );

    Object.defineProperty( Material.prototype, 'needsUpdate', {

        set: function ( value ) {

                if ( value === true ) this.version ++;

        }

    } );

    /**
     * parameters = {
     *  color: <hex>,
     *  opacity: <float>,
     *  map: new THREE.Texture( <Image> ),
     *
     *  lightMap: new THREE.Texture( <Image> ),
     *  lightMapIntensity: <float>
     *
     *  aoMap: new THREE.Texture( <Image> ),
     *  aoMapIntensity: <float>
     *
     *  specularMap: new THREE.Texture( <Image> ),
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
     *  combine: THREE.Multiply,
     *  reflectivity: <float>,
     *  refractionRatio: <float>,
     *
     *  depthTest: <bool>,
     *  depthWrite: <bool>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>
     * }
     */

    function MeshBasicMaterial( parameters ) {

        Material.call( this );

        this.type = 'MeshBasicMaterial';

        this.color = new Color( 0xffffff ); // emissive

        this.map = null;

        this.lightMap = null;
        this.lightMapIntensity = 1.0;

        this.aoMap = null;
        this.aoMapIntensity = 1.0;

        this.specularMap = null;

        this.alphaMap = null;

        this.envMap = null;
        this.combine = MultiplyOperation;
        this.reflectivity = 1;
        this.refractionRatio = 0.98;

        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';

        this.skinning = false;
        this.morphTargets = false;

        this.setValues( parameters );

    }

    MeshBasicMaterial.prototype = Object.create( Material.prototype );
    MeshBasicMaterial.prototype.constructor = MeshBasicMaterial;

    MeshBasicMaterial.prototype.isMeshBasicMaterial = true;

    MeshBasicMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        this.map = source.map;

        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;

        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;

        this.specularMap = source.specularMap;

        this.alphaMap = source.alphaMap;

        this.envMap = source.envMap;
        this.combine = source.combine;
        this.reflectivity = source.reflectivity;
        this.refractionRatio = source.refractionRatio;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;

        return this;

    };

    const _vector$3 = new Vector3();
    const _vector2$1 = new Vector2();

    function BufferAttribute( array, itemSize, normalized ) {

        if ( Array.isArray( array ) ) {

                throw new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );

        }

        this.name = '';

        this.array = array;
        this.itemSize = itemSize;
        this.count = array !== undefined ? array.length / itemSize : 0;
        this.normalized = normalized === true;

        this.usage = StaticDrawUsage;
        this.updateRange = { offset: 0, count: - 1 };

        this.version = 0;

    }

    Object.defineProperty( BufferAttribute.prototype, 'needsUpdate', {

        set: function ( value ) {

                if ( value === true ) this.version ++;

        }

    } );

    Object.assign( BufferAttribute.prototype, {

        isBufferAttribute: true,

        onUploadCallback: function () {},

        setUsage: function ( value ) {

                this.usage = value;

                return this;

        },

        copy: function ( source ) {

                this.name = source.name;
                this.array = new source.array.constructor( source.array );
                this.itemSize = source.itemSize;
                this.count = source.count;
                this.normalized = source.normalized;

                this.usage = source.usage;

                return this;

        },

        copyAt: function ( index1, attribute, index2 ) {

                index1 *= this.itemSize;
                index2 *= attribute.itemSize;

                for ( let i = 0, l = this.itemSize; i < l; i ++ ) {

                        this.array[ index1 + i ] = attribute.array[ index2 + i ];

                }

                return this;

        },

        copyArray: function ( array ) {

                this.array.set( array );

                return this;

        },

        copyColorsArray: function ( colors ) {

                const array = this.array;
                let offset = 0;

                for ( let i = 0, l = colors.length; i < l; i ++ ) {

                        let color = colors[ i ];

                        if ( color === undefined ) {

                                console.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i );
                                color = new Color();

                        }

                        array[ offset ++ ] = color.r;
                        array[ offset ++ ] = color.g;
                        array[ offset ++ ] = color.b;

                }

                return this;

        },

        copyVector2sArray: function ( vectors ) {

                const array = this.array;
                let offset = 0;

                for ( let i = 0, l = vectors.length; i < l; i ++ ) {

                        let vector = vectors[ i ];

                        if ( vector === undefined ) {

                                console.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i );
                                vector = new Vector2();

                        }

                        array[ offset ++ ] = vector.x;
                        array[ offset ++ ] = vector.y;

                }

                return this;

        },

        copyVector3sArray: function ( vectors ) {

                const array = this.array;
                let offset = 0;

                for ( let i = 0, l = vectors.length; i < l; i ++ ) {

                        let vector = vectors[ i ];

                        if ( vector === undefined ) {

                                console.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i );
                                vector = new Vector3();

                        }

                        array[ offset ++ ] = vector.x;
                        array[ offset ++ ] = vector.y;
                        array[ offset ++ ] = vector.z;

                }

                return this;

        },

        copyVector4sArray: function ( vectors ) {

                const array = this.array;
                let offset = 0;

                for ( let i = 0, l = vectors.length; i < l; i ++ ) {

                        let vector = vectors[ i ];

                        if ( vector === undefined ) {

                                console.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i );
                                vector = new Vector4();

                        }

                        array[ offset ++ ] = vector.x;
                        array[ offset ++ ] = vector.y;
                        array[ offset ++ ] = vector.z;
                        array[ offset ++ ] = vector.w;

                }

                return this;

        },

        applyMatrix3: function ( m ) {

                if ( this.itemSize === 2 ) {

                        for ( let i = 0, l = this.count; i < l; i ++ ) {

                                _vector2$1.fromBufferAttribute( this, i );
                                _vector2$1.applyMatrix3( m );

                                this.setXY( i, _vector2$1.x, _vector2$1.y );

                        }

                } else if ( this.itemSize === 3 ) {

                        for ( let i = 0, l = this.count; i < l; i ++ ) {

                                _vector$3.fromBufferAttribute( this, i );
                                _vector$3.applyMatrix3( m );

                                this.setXYZ( i, _vector$3.x, _vector$3.y, _vector$3.z );

                        }

                }

                return this;

        },

        applyMatrix4: function ( m ) {

                for ( let i = 0, l = this.count; i < l; i ++ ) {

                        _vector$3.x = this.getX( i );
                        _vector$3.y = this.getY( i );
                        _vector$3.z = this.getZ( i );

                        _vector$3.applyMatrix4( m );

                        this.setXYZ( i, _vector$3.x, _vector$3.y, _vector$3.z );

                }

                return this;

        },

        applyNormalMatrix: function ( m ) {

                for ( let i = 0, l = this.count; i < l; i ++ ) {

                        _vector$3.x = this.getX( i );
                        _vector$3.y = this.getY( i );
                        _vector$3.z = this.getZ( i );

                        _vector$3.applyNormalMatrix( m );

                        this.setXYZ( i, _vector$3.x, _vector$3.y, _vector$3.z );

                }

                return this;

        },

        transformDirection: function ( m ) {

                for ( let i = 0, l = this.count; i < l; i ++ ) {

                        _vector$3.x = this.getX( i );
                        _vector$3.y = this.getY( i );
                        _vector$3.z = this.getZ( i );

                        _vector$3.transformDirection( m );

                        this.setXYZ( i, _vector$3.x, _vector$3.y, _vector$3.z );

                }

                return this;

        },

        set: function ( value, offset = 0 ) {

                this.array.set( value, offset );

                return this;

        },

        getX: function ( index ) {

                return this.array[ index * this.itemSize ];

        },

        setX: function ( index, x ) {

                this.array[ index * this.itemSize ] = x;

                return this;

        },

        getY: function ( index ) {

                return this.array[ index * this.itemSize + 1 ];

        },

        setY: function ( index, y ) {

                this.array[ index * this.itemSize + 1 ] = y;

                return this;

        },

        getZ: function ( index ) {

                return this.array[ index * this.itemSize + 2 ];

        },

        setZ: function ( index, z ) {

                this.array[ index * this.itemSize + 2 ] = z;

                return this;

        },

        getW: function ( index ) {

                return this.array[ index * this.itemSize + 3 ];

        },

        setW: function ( index, w ) {

                this.array[ index * this.itemSize + 3 ] = w;

                return this;

        },

        setXY: function ( index, x, y ) {

                index *= this.itemSize;

                this.array[ index + 0 ] = x;
                this.array[ index + 1 ] = y;

                return this;

        },

        setXYZ: function ( index, x, y, z ) {

                index *= this.itemSize;

                this.array[ index + 0 ] = x;
                this.array[ index + 1 ] = y;
                this.array[ index + 2 ] = z;

                return this;

        },

        setXYZW: function ( index, x, y, z, w ) {

                index *= this.itemSize;

                this.array[ index + 0 ] = x;
                this.array[ index + 1 ] = y;
                this.array[ index + 2 ] = z;
                this.array[ index + 3 ] = w;

                return this;

        },

        onUpload: function ( callback ) {

                this.onUploadCallback = callback;

                return this;

        },

        clone: function () {

                return new this.constructor( this.array, this.itemSize ).copy( this );

        },

        toJSON: function () {

                return {
                        itemSize: this.itemSize,
                        type: this.array.constructor.name,
                        array: Array.prototype.slice.call( this.array ),
                        normalized: this.normalized
                };

        }

    } );

    //

    function Int8BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Int8Array( array ), itemSize, normalized );

    }

    Int8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Int8BufferAttribute.prototype.constructor = Int8BufferAttribute;


    function Uint8BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Uint8Array( array ), itemSize, normalized );

    }

    Uint8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Uint8BufferAttribute.prototype.constructor = Uint8BufferAttribute;


    function Uint8ClampedBufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Uint8ClampedArray( array ), itemSize, normalized );

    }

    Uint8ClampedBufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Uint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute;


    function Int16BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Int16Array( array ), itemSize, normalized );

    }

    Int16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Int16BufferAttribute.prototype.constructor = Int16BufferAttribute;


    function Uint16BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Uint16Array( array ), itemSize, normalized );

    }

    Uint16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Uint16BufferAttribute.prototype.constructor = Uint16BufferAttribute;


    function Int32BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Int32Array( array ), itemSize, normalized );

    }

    Int32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Int32BufferAttribute.prototype.constructor = Int32BufferAttribute;


    function Uint32BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Uint32Array( array ), itemSize, normalized );

    }

    Uint32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Uint32BufferAttribute.prototype.constructor = Uint32BufferAttribute;

    function Float16BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Uint16Array( array ), itemSize, normalized );

    }

    Float16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Float16BufferAttribute.prototype.constructor = Float16BufferAttribute;
    Float16BufferAttribute.prototype.isFloat16BufferAttribute = true;

    function Float32BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Float32Array( array ), itemSize, normalized );

    }

    Float32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Float32BufferAttribute.prototype.constructor = Float32BufferAttribute;


    function Float64BufferAttribute( array, itemSize, normalized ) {

        BufferAttribute.call( this, new Float64Array( array ), itemSize, normalized );

    }

    Float64BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
    Float64BufferAttribute.prototype.constructor = Float64BufferAttribute;

    function arrayMax( array ) {

        if ( array.length === 0 ) return - Infinity;

        let max = array[ 0 ];

        for ( let i = 1, l = array.length; i < l; ++ i ) {

                if ( array[ i ] > max ) max = array[ i ];

        }

        return max;

    }

    const TYPED_ARRAYS = {
        Int8Array: Int8Array,
        Uint8Array: Uint8Array,
        // Workaround for IE11 pre KB2929437. See #11440
        Uint8ClampedArray: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : Uint8Array,
        Int16Array: Int16Array,
        Uint16Array: Uint16Array,
        Int32Array: Int32Array,
        Uint32Array: Uint32Array,
        Float32Array: Float32Array,
        Float64Array: Float64Array
    };

    function getTypedArray( type, buffer ) {

        return new TYPED_ARRAYS[ type ]( buffer );

    }

    let _id = 0;

    const _m1$2 = new Matrix4();
    const _obj = new Object3D();
    const _offset = new Vector3();
    const _box$2 = new Box3();
    const _boxMorphTargets = new Box3();
    const _vector$4 = new Vector3();

    function BufferGeometry() {

        Object.defineProperty( this, 'id', { value: _id ++ } );

        this.uuid = MathUtils.generateUUID();

        this.name = '';
        this.type = 'BufferGeometry';

        this.index = null;
        this.attributes = {};

        this.morphAttributes = {};
        this.morphTargetsRelative = false;

        this.groups = [];

        this.boundingBox = null;
        this.boundingSphere = null;

        this.drawRange = { start: 0, count: Infinity };

        this.userData = {};

    }

    BufferGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {

        constructor: BufferGeometry,

        isBufferGeometry: true,

        getIndex: function () {

                return this.index;

        },

        setIndex: function ( index ) {

                if ( Array.isArray( index ) ) {

                        this.index = new ( arrayMax( index ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );

                } else {

                        this.index = index;

                }

                return this;

        },

        getAttribute: function ( name ) {

                return this.attributes[ name ];

        },

        setAttribute: function ( name, attribute ) {

                this.attributes[ name ] = attribute;

                return this;

        },

        deleteAttribute: function ( name ) {

                delete this.attributes[ name ];

                return this;

        },

        hasAttribute: function ( name ) {

                return this.attributes[ name ] !== undefined;

        },

        addGroup: function ( start, count, materialIndex = 0 ) {

                this.groups.push( {

                        start: start,
                        count: count,
                        materialIndex: materialIndex

                } );

        },

        clearGroups: function () {

                this.groups = [];

        },

        setDrawRange: function ( start, count ) {

                this.drawRange.start = start;
                this.drawRange.count = count;

        },

        applyMatrix4: function ( matrix ) {

                const position = this.attributes.position;

                if ( position !== undefined ) {

                        position.applyMatrix4( matrix );

                        position.needsUpdate = true;

                }

                const normal = this.attributes.normal;

                if ( normal !== undefined ) {

                        const normalMatrix = new Matrix3().getNormalMatrix( matrix );

                        normal.applyNormalMatrix( normalMatrix );

                        normal.needsUpdate = true;

                }

                const tangent = this.attributes.tangent;

                if ( tangent !== undefined ) {

                        tangent.transformDirection( matrix );

                        tangent.needsUpdate = true;

                }

                if ( this.boundingBox !== null ) {

                        this.computeBoundingBox();

                }

                if ( this.boundingSphere !== null ) {

                        this.computeBoundingSphere();

                }

                return this;

        },

        rotateX: function ( angle ) {

                // rotate geometry around world x-axis

                _m1$2.makeRotationX( angle );

                this.applyMatrix4( _m1$2 );

                return this;

        },

        rotateY: function ( angle ) {

                // rotate geometry around world y-axis

                _m1$2.makeRotationY( angle );

                this.applyMatrix4( _m1$2 );

                return this;

        },

        rotateZ: function ( angle ) {

                // rotate geometry around world z-axis

                _m1$2.makeRotationZ( angle );

                this.applyMatrix4( _m1$2 );

                return this;

        },

        translate: function ( x, y, z ) {

                // translate geometry

                _m1$2.makeTranslation( x, y, z );

                this.applyMatrix4( _m1$2 );

                return this;

        },

        scale: function ( x, y, z ) {

                // scale geometry

                _m1$2.makeScale( x, y, z );

                this.applyMatrix4( _m1$2 );

                return this;

        },

        lookAt: function ( vector ) {

                _obj.lookAt( vector );

                _obj.updateMatrix();

                this.applyMatrix4( _obj.matrix );

                return this;

        },

        center: function () {

                this.computeBoundingBox();

                this.boundingBox.getCenter( _offset ).negate();

                this.translate( _offset.x, _offset.y, _offset.z );

                return this;

        },

        setFromPoints: function ( points ) {

                const position = [];

                for ( let i = 0, l = points.length; i < l; i ++ ) {

                        const point = points[ i ];
                        position.push( point.x, point.y, point.z || 0 );

                }

                this.setAttribute( 'position', new Float32BufferAttribute( position, 3 ) );

                return this;

        },

        computeBoundingBox: function () {

                if ( this.boundingBox === null ) {

                        this.boundingBox = new Box3();

                }

                const position = this.attributes.position;
                const morphAttributesPosition = this.morphAttributes.position;

                if ( position && position.isGLBufferAttribute ) {

                        console.error( 'THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".', this );

                        this.boundingBox.set(
                                new Vector3( - Infinity, - Infinity, - Infinity ),
                                new Vector3( + Infinity, + Infinity, + Infinity )
                        );

                        return;

                }

                if ( position !== undefined ) {

                        this.boundingBox.setFromBufferAttribute( position );

                        // process morph attributes if present

                        if ( morphAttributesPosition ) {

                                for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {

                                        const morphAttribute = morphAttributesPosition[ i ];
                                        _box$2.setFromBufferAttribute( morphAttribute );

                                        if ( this.morphTargetsRelative ) {

                                                _vector$4.addVectors( this.boundingBox.min, _box$2.min );
                                                this.boundingBox.expandByPoint( _vector$4 );

                                                _vector$4.addVectors( this.boundingBox.max, _box$2.max );
                                                this.boundingBox.expandByPoint( _vector$4 );

                                        } else {

                                                this.boundingBox.expandByPoint( _box$2.min );
                                                this.boundingBox.expandByPoint( _box$2.max );

                                        }

                                }

                        }

                } else {

                        this.boundingBox.makeEmpty();

                }

                if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {

                        console.error( 'THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this );

                }

        },

        computeBoundingSphere: function () {

                if ( this.boundingSphere === null ) {

                        this.boundingSphere = new Sphere();

                }

                const position = this.attributes.position;
                const morphAttributesPosition = this.morphAttributes.position;

                if ( position && position.isGLBufferAttribute ) {

                        console.error( 'THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".', this );

                        this.boundingSphere.set( new Vector3(), Infinity );

                        return;

                }

                if ( position ) {

                        // first, find the center of the bounding sphere

                        const center = this.boundingSphere.center;

                        _box$2.setFromBufferAttribute( position );

                        // process morph attributes if present

                        if ( morphAttributesPosition ) {

                                for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {

                                        const morphAttribute = morphAttributesPosition[ i ];
                                        _boxMorphTargets.setFromBufferAttribute( morphAttribute );

                                        if ( this.morphTargetsRelative ) {

                                                _vector$4.addVectors( _box$2.min, _boxMorphTargets.min );
                                                _box$2.expandByPoint( _vector$4 );

                                                _vector$4.addVectors( _box$2.max, _boxMorphTargets.max );
                                                _box$2.expandByPoint( _vector$4 );

                                        } else {

                                                _box$2.expandByPoint( _boxMorphTargets.min );
                                                _box$2.expandByPoint( _boxMorphTargets.max );

                                        }

                                }

                        }

                        _box$2.getCenter( center );

                        // second, try to find a boundingSphere with a radius smaller than the
                        // boundingSphere of the boundingBox: sqrt(3) smaller in the best case

                        let maxRadiusSq = 0;

                        for ( let i = 0, il = position.count; i < il; i ++ ) {

                                _vector$4.fromBufferAttribute( position, i );

                                maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector$4 ) );

                        }

                        // process morph attributes if present

                        if ( morphAttributesPosition ) {

                                for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {

                                        const morphAttribute = morphAttributesPosition[ i ];
                                        const morphTargetsRelative = this.morphTargetsRelative;

                                        for ( let j = 0, jl = morphAttribute.count; j < jl; j ++ ) {

                                                _vector$4.fromBufferAttribute( morphAttribute, j );

                                                if ( morphTargetsRelative ) {

                                                        _offset.fromBufferAttribute( position, j );
                                                        _vector$4.add( _offset );

                                                }

                                                maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector$4 ) );

                                        }

                                }

                        }

                        this.boundingSphere.radius = Math.sqrt( maxRadiusSq );

                        if ( isNaN( this.boundingSphere.radius ) ) {

                                console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this );

                        }

                }

        },

        computeFaceNormals: function () {

                // backwards compatibility

        },

        computeTangents: function () {

                const index = this.index;
                const attributes = this.attributes;

                // based on http://www.terathon.com/code/tangent.html
                // (per vertex tangents)

                if ( index === null ||
                         attributes.position === undefined ||
                         attributes.normal === undefined ||
                         attributes.uv === undefined ) {

                        console.error( 'THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)' );
                        return;

                }

                const indices = index.array;
                const positions = attributes.position.array;
                const normals = attributes.normal.array;
                const uvs = attributes.uv.array;

                const nVertices = positions.length / 3;

                if ( attributes.tangent === undefined ) {

                        this.setAttribute( 'tangent', new BufferAttribute( new Float32Array( 4 * nVertices ), 4 ) );

                }

                const tangents = attributes.tangent.array;

                const tan1 = [], tan2 = [];

                for ( let i = 0; i < nVertices; i ++ ) {

                        tan1[ i ] = new Vector3();
                        tan2[ i ] = new Vector3();

                }

                const vA = new Vector3(),
                        vB = new Vector3(),
                        vC = new Vector3(),

                        uvA = new Vector2(),
                        uvB = new Vector2(),
                        uvC = new Vector2(),

                        sdir = new Vector3(),
                        tdir = new Vector3();

                function handleTriangle( a, b, c ) {

                        vA.fromArray( positions, a * 3 );
                        vB.fromArray( positions, b * 3 );
                        vC.fromArray( positions, c * 3 );

                        uvA.fromArray( uvs, a * 2 );
                        uvB.fromArray( uvs, b * 2 );
                        uvC.fromArray( uvs, c * 2 );

                        vB.sub( vA );
                        vC.sub( vA );

                        uvB.sub( uvA );
                        uvC.sub( uvA );

                        const r = 1.0 / ( uvB.x * uvC.y - uvC.x * uvB.y );

                        // silently ignore degenerate uv triangles having coincident or colinear vertices

                        if ( ! isFinite( r ) ) return;

                        sdir.copy( vB ).multiplyScalar( uvC.y ).addScaledVector( vC, - uvB.y ).multiplyScalar( r );
                        tdir.copy( vC ).multiplyScalar( uvB.x ).addScaledVector( vB, - uvC.x ).multiplyScalar( r );

                        tan1[ a ].add( sdir );
                        tan1[ b ].add( sdir );
                        tan1[ c ].add( sdir );

                        tan2[ a ].add( tdir );
                        tan2[ b ].add( tdir );
                        tan2[ c ].add( tdir );

                }

                let groups = this.groups;

                if ( groups.length === 0 ) {

                        groups = [ {
                                start: 0,
                                count: indices.length
                        } ];

                }

                for ( let i = 0, il = groups.length; i < il; ++ i ) {

                        const group = groups[ i ];

                        const start = group.start;
                        const count = group.count;

                        for ( let j = start, jl = start + count; j < jl; j += 3 ) {

                                handleTriangle(
                                        indices[ j + 0 ],
                                        indices[ j + 1 ],
                                        indices[ j + 2 ]
                                );

                        }

                }

                const tmp = new Vector3(), tmp2 = new Vector3();
                const n = new Vector3(), n2 = new Vector3();

                function handleVertex( v ) {

                        n.fromArray( normals, v * 3 );
                        n2.copy( n );

                        const t = tan1[ v ];

                        // Gram-Schmidt orthogonalize

                        tmp.copy( t );
                        tmp.sub( n.multiplyScalar( n.dot( t ) ) ).normalize();

                        // Calculate handedness

                        tmp2.crossVectors( n2, t );
                        const test = tmp2.dot( tan2[ v ] );
                        const w = ( test < 0.0 ) ? - 1.0 : 1.0;

                        tangents[ v * 4 ] = tmp.x;
                        tangents[ v * 4 + 1 ] = tmp.y;
                        tangents[ v * 4 + 2 ] = tmp.z;
                        tangents[ v * 4 + 3 ] = w;

                }

                for ( let i = 0, il = groups.length; i < il; ++ i ) {

                        const group = groups[ i ];

                        const start = group.start;
                        const count = group.count;

                        for ( let j = start, jl = start + count; j < jl; j += 3 ) {

                                handleVertex( indices[ j + 0 ] );
                                handleVertex( indices[ j + 1 ] );
                                handleVertex( indices[ j + 2 ] );

                        }

                }

        },

        computeVertexNormals: function () {

                const index = this.index;
                const positionAttribute = this.getAttribute( 'position' );

                if ( positionAttribute !== undefined ) {

                        let normalAttribute = this.getAttribute( 'normal' );

                        if ( normalAttribute === undefined ) {

                                normalAttribute = new BufferAttribute( new Float32Array( positionAttribute.count * 3 ), 3 );
                                this.setAttribute( 'normal', normalAttribute );

                        } else {

                                // reset existing normals to zero

                                for ( let i = 0, il = normalAttribute.count; i < il; i ++ ) {

                                        normalAttribute.setXYZ( i, 0, 0, 0 );

                                }

                        }

                        const pA = new Vector3(), pB = new Vector3(), pC = new Vector3();
                        const nA = new Vector3(), nB = new Vector3(), nC = new Vector3();
                        const cb = new Vector3(), ab = new Vector3();

                        // indexed elements

                        if ( index ) {

                                for ( let i = 0, il = index.count; i < il; i += 3 ) {

                                        const vA = index.getX( i + 0 );
                                        const vB = index.getX( i + 1 );
                                        const vC = index.getX( i + 2 );

                                        pA.fromBufferAttribute( positionAttribute, vA );
                                        pB.fromBufferAttribute( positionAttribute, vB );
                                        pC.fromBufferAttribute( positionAttribute, vC );

                                        cb.subVectors( pC, pB );
                                        ab.subVectors( pA, pB );
                                        cb.cross( ab );

                                        nA.fromBufferAttribute( normalAttribute, vA );
                                        nB.fromBufferAttribute( normalAttribute, vB );
                                        nC.fromBufferAttribute( normalAttribute, vC );

                                        nA.add( cb );
                                        nB.add( cb );
                                        nC.add( cb );

                                        normalAttribute.setXYZ( vA, nA.x, nA.y, nA.z );
                                        normalAttribute.setXYZ( vB, nB.x, nB.y, nB.z );
                                        normalAttribute.setXYZ( vC, nC.x, nC.y, nC.z );

                                }

                        } else {

                                // non-indexed elements (unconnected triangle soup)

                                for ( let i = 0, il = positionAttribute.count; i < il; i += 3 ) {

                                        pA.fromBufferAttribute( positionAttribute, i + 0 );
                                        pB.fromBufferAttribute( positionAttribute, i + 1 );
                                        pC.fromBufferAttribute( positionAttribute, i + 2 );

                                        cb.subVectors( pC, pB );
                                        ab.subVectors( pA, pB );
                                        cb.cross( ab );

                                        normalAttribute.setXYZ( i + 0, cb.x, cb.y, cb.z );
                                        normalAttribute.setXYZ( i + 1, cb.x, cb.y, cb.z );
                                        normalAttribute.setXYZ( i + 2, cb.x, cb.y, cb.z );

                                }

                        }

                        this.normalizeNormals();

                        normalAttribute.needsUpdate = true;

                }

        },

        merge: function ( geometry, offset ) {

                if ( ! ( geometry && geometry.isBufferGeometry ) ) {

                        console.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry );
                        return;

                }

                if ( offset === undefined ) {

                        offset = 0;

                        console.warn(
                                'THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. '
                                + 'Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge.'
                        );

                }

                const attributes = this.attributes;

                for ( const key in attributes ) {

                        if ( geometry.attributes[ key ] === undefined ) continue;

                        const attribute1 = attributes[ key ];
                        const attributeArray1 = attribute1.array;

                        const attribute2 = geometry.attributes[ key ];
                        const attributeArray2 = attribute2.array;

                        const attributeOffset = attribute2.itemSize * offset;
                        const length = Math.min( attributeArray2.length, attributeArray1.length - attributeOffset );

                        for ( let i = 0, j = attributeOffset; i < length; i ++, j ++ ) {

                                attributeArray1[ j ] = attributeArray2[ i ];

                        }

                }

                return this;

        },

        normalizeNormals: function () {

                const normals = this.attributes.normal;

                for ( let i = 0, il = normals.count; i < il; i ++ ) {

                        _vector$4.fromBufferAttribute( normals, i );

                        _vector$4.normalize();

                        normals.setXYZ( i, _vector$4.x, _vector$4.y, _vector$4.z );

                }

        },

        toNonIndexed: function () {

                function convertBufferAttribute( attribute, indices ) {

                        const array = attribute.array;
                        const itemSize = attribute.itemSize;
                        const normalized = attribute.normalized;

                        const array2 = new array.constructor( indices.length * itemSize );

                        let index = 0, index2 = 0;

                        for ( let i = 0, l = indices.length; i < l; i ++ ) {

                                index = indices[ i ] * itemSize;

                                for ( let j = 0; j < itemSize; j ++ ) {

                                        array2[ index2 ++ ] = array[ index ++ ];

                                }

                        }

                        return new BufferAttribute( array2, itemSize, normalized );

                }

                //

                if ( this.index === null ) {

                        console.warn( 'THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed.' );
                        return this;

                }

                const geometry2 = new BufferGeometry();

                const indices = this.index.array;
                const attributes = this.attributes;

                // attributes

                for ( const name in attributes ) {

                        const attribute = attributes[ name ];

                        const newAttribute = convertBufferAttribute( attribute, indices );

                        geometry2.setAttribute( name, newAttribute );

                }

                // morph attributes

                const morphAttributes = this.morphAttributes;

                for ( const name in morphAttributes ) {

                        const morphArray = [];
                        const morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes

                        for ( let i = 0, il = morphAttribute.length; i < il; i ++ ) {

                                const attribute = morphAttribute[ i ];

                                const newAttribute = convertBufferAttribute( attribute, indices );

                                morphArray.push( newAttribute );

                        }

                        geometry2.morphAttributes[ name ] = morphArray;

                }

                geometry2.morphTargetsRelative = this.morphTargetsRelative;

                // groups

                const groups = this.groups;

                for ( let i = 0, l = groups.length; i < l; i ++ ) {

                        const group = groups[ i ];
                        geometry2.addGroup( group.start, group.count, group.materialIndex );

                }

                return geometry2;

        },

        toJSON: function () {

                const data = {
                        metadata: {
                                version: 4.5,
                                type: 'BufferGeometry',
                                generator: 'BufferGeometry.toJSON'
                        }
                };

                // standard BufferGeometry serialization

                data.uuid = this.uuid;
                data.type = this.type;
                if ( this.name !== '' ) data.name = this.name;
                if ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;

                if ( this.parameters !== undefined ) {

                        const parameters = this.parameters;

                        for ( const key in parameters ) {

                                if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];

                        }

                        return data;

                }

                data.data = { attributes: {} };

                const index = this.index;

                if ( index !== null ) {

                        data.data.index = {
                                type: index.array.constructor.name,
                                array: Array.prototype.slice.call( index.array )
                        };

                }

                const attributes = this.attributes;

                for ( const key in attributes ) {

                        const attribute = attributes[ key ];

                        const attributeData = attribute.toJSON( data.data );

                        if ( attribute.name !== '' ) attributeData.name = attribute.name;

                        data.data.attributes[ key ] = attributeData;

                }

                const morphAttributes = {};
                let hasMorphAttributes = false;

                for ( const key in this.morphAttributes ) {

                        const attributeArray = this.morphAttributes[ key ];

                        const array = [];

                        for ( let i = 0, il = attributeArray.length; i < il; i ++ ) {

                                const attribute = attributeArray[ i ];

                                const attributeData = attribute.toJSON( data.data );

                                if ( attribute.name !== '' ) attributeData.name = attribute.name;

                                array.push( attributeData );

                        }

                        if ( array.length > 0 ) {

                                morphAttributes[ key ] = array;

                                hasMorphAttributes = true;

                        }

                }

                if ( hasMorphAttributes ) {

                        data.data.morphAttributes = morphAttributes;
                        data.data.morphTargetsRelative = this.morphTargetsRelative;

                }

                const groups = this.groups;

                if ( groups.length > 0 ) {

                        data.data.groups = JSON.parse( JSON.stringify( groups ) );

                }

                const boundingSphere = this.boundingSphere;

                if ( boundingSphere !== null ) {

                        data.data.boundingSphere = {
                                center: boundingSphere.center.toArray(),
                                radius: boundingSphere.radius
                        };

                }

                return data;

        },

        clone: function () {

                /*
                 // Handle primitives

                 const parameters = this.parameters;

                 if ( parameters !== undefined ) {

                 const values = [];

                 for ( const key in parameters ) {

                 values.push( parameters[ key ] );

                 }

                 const geometry = Object.create( this.constructor.prototype );
                 this.constructor.apply( geometry, values );
                 return geometry;

                 }

                 return new this.constructor().copy( this );
                 */

                return new BufferGeometry().copy( this );

        },

        copy: function ( source ) {

                // reset

                this.index = null;
                this.attributes = {};
                this.morphAttributes = {};
                this.groups = [];
                this.boundingBox = null;
                this.boundingSphere = null;

                // used for storing cloned, shared data

                const data = {};

                // name

                this.name = source.name;

                // index

                const index = source.index;

                if ( index !== null ) {

                        this.setIndex( index.clone( data ) );

                }

                // attributes

                const attributes = source.attributes;

                for ( const name in attributes ) {

                        const attribute = attributes[ name ];
                        this.setAttribute( name, attribute.clone( data ) );

                }

                // morph attributes

                const morphAttributes = source.morphAttributes;

                for ( const name in morphAttributes ) {

                        const array = [];
                        const morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes

                        for ( let i = 0, l = morphAttribute.length; i < l; i ++ ) {

                                array.push( morphAttribute[ i ].clone( data ) );

                        }

                        this.morphAttributes[ name ] = array;

                }

                this.morphTargetsRelative = source.morphTargetsRelative;

                // groups

                const groups = source.groups;

                for ( let i = 0, l = groups.length; i < l; i ++ ) {

                        const group = groups[ i ];
                        this.addGroup( group.start, group.count, group.materialIndex );

                }

                // bounding box

                const boundingBox = source.boundingBox;

                if ( boundingBox !== null ) {

                        this.boundingBox = boundingBox.clone();

                }

                // bounding sphere

                const boundingSphere = source.boundingSphere;

                if ( boundingSphere !== null ) {

                        this.boundingSphere = boundingSphere.clone();

                }

                // draw range

                this.drawRange.start = source.drawRange.start;
                this.drawRange.count = source.drawRange.count;

                // user data

                this.userData = source.userData;

                return this;

        },

        dispose: function () {

                this.dispatchEvent( { type: 'dispose' } );

        }

    } );

    const _inverseMatrix = new Matrix4();
    const _ray = new Ray();
    const _sphere = new Sphere();

    const _vA = new Vector3();
    const _vB = new Vector3();
    const _vC = new Vector3();

    const _tempA = new Vector3();
    const _tempB = new Vector3();
    const _tempC = new Vector3();

    const _morphA = new Vector3();
    const _morphB = new Vector3();
    const _morphC = new Vector3();

    const _uvA = new Vector2();
    const _uvB = new Vector2();
    const _uvC = new Vector2();

    const _intersectionPoint = new Vector3();
    const _intersectionPointWorld = new Vector3();

    function Mesh( geometry = new BufferGeometry(), material = new MeshBasicMaterial() ) {

        Object3D.call( this );

        this.type = 'Mesh';

        this.geometry = geometry;
        this.material = material;

        this.updateMorphTargets();

    }

    Mesh.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Mesh,

        isMesh: true,

        copy: function ( source ) {

                Object3D.prototype.copy.call( this, source );

                if ( source.morphTargetInfluences !== undefined ) {

                        this.morphTargetInfluences = source.morphTargetInfluences.slice();

                }

                if ( source.morphTargetDictionary !== undefined ) {

                        this.morphTargetDictionary = Object.assign( {}, source.morphTargetDictionary );

                }

                this.material = source.material;
                this.geometry = source.geometry;

                return this;

        },

        updateMorphTargets: function () {

                const geometry = this.geometry;

                if ( geometry.isBufferGeometry ) {

                        const morphAttributes = geometry.morphAttributes;
                        const keys = Object.keys( morphAttributes );

                        if ( keys.length > 0 ) {

                                const morphAttribute = morphAttributes[ keys[ 0 ] ];

                                if ( morphAttribute !== undefined ) {

                                        this.morphTargetInfluences = [];
                                        this.morphTargetDictionary = {};

                                        for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {

                                                const name = morphAttribute[ m ].name || String( m );

                                                this.morphTargetInfluences.push( 0 );
                                                this.morphTargetDictionary[ name ] = m;

                                        }

                                }

                        }

                } else {

                        const morphTargets = geometry.morphTargets;

                        if ( morphTargets !== undefined && morphTargets.length > 0 ) {

                                console.error( 'THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

                        }

                }

        },

        raycast: function ( raycaster, intersects ) {

                const geometry = this.geometry;
                const material = this.material;
                const matrixWorld = this.matrixWorld;

                if ( material === undefined ) return;

                // Checking boundingSphere distance to ray

                if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();

                _sphere.copy( geometry.boundingSphere );
                _sphere.applyMatrix4( matrixWorld );

                if ( raycaster.ray.intersectsSphere( _sphere ) === false ) return;

                //

                _inverseMatrix.copy( matrixWorld ).invert();
                _ray.copy( raycaster.ray ).applyMatrix4( _inverseMatrix );

                // Check boundingBox before continuing

                if ( geometry.boundingBox !== null ) {

                        if ( _ray.intersectsBox( geometry.boundingBox ) === false ) return;

                }

                let intersection;

                if ( geometry.isBufferGeometry ) {

                        const index = geometry.index;
                        const position = geometry.attributes.position;
                        const morphPosition = geometry.morphAttributes.position;
                        const morphTargetsRelative = geometry.morphTargetsRelative;
                        const uv = geometry.attributes.uv;
                        const uv2 = geometry.attributes.uv2;
                        const groups = geometry.groups;
                        const drawRange = geometry.drawRange;

                        if ( index !== null ) {

                                // indexed buffer geometry

                                if ( Array.isArray( material ) ) {

                                        for ( let i = 0, il = groups.length; i < il; i ++ ) {

                                                const group = groups[ i ];
                                                const groupMaterial = material[ group.materialIndex ];

                                                const start = Math.max( group.start, drawRange.start );
                                                const end = Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) );

                                                for ( let j = start, jl = end; j < jl; j += 3 ) {

                                                        const a = index.getX( j );
                                                        const b = index.getX( j + 1 );
                                                        const c = index.getX( j + 2 );

                                                        intersection = checkBufferGeometryIntersection( this, groupMaterial, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c );

                                                        if ( intersection ) {

                                                                intersection.faceIndex = Math.floor( j / 3 ); // triangle number in indexed buffer semantics
                                                                intersection.face.materialIndex = group.materialIndex;
                                                                intersects.push( intersection );

                                                        }

                                                }

                                        }

                                } else {

                                        const start = Math.max( 0, drawRange.start );
                                        const end = Math.min( index.count, ( drawRange.start + drawRange.count ) );

                                        for ( let i = start, il = end; i < il; i += 3 ) {

                                                const a = index.getX( i );
                                                const b = index.getX( i + 1 );
                                                const c = index.getX( i + 2 );

                                                intersection = checkBufferGeometryIntersection( this, material, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c );

                                                if ( intersection ) {

                                                        intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indexed buffer semantics
                                                        intersects.push( intersection );

                                                }

                                        }

                                }

                        } else if ( position !== undefined ) {

                                // non-indexed buffer geometry

                                if ( Array.isArray( material ) ) {

                                        for ( let i = 0, il = groups.length; i < il; i ++ ) {

                                                const group = groups[ i ];
                                                const groupMaterial = material[ group.materialIndex ];

                                                const start = Math.max( group.start, drawRange.start );
                                                const end = Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) );

                                                for ( let j = start, jl = end; j < jl; j += 3 ) {

                                                        const a = j;
                                                        const b = j + 1;
                                                        const c = j + 2;

                                                        intersection = checkBufferGeometryIntersection( this, groupMaterial, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c );

                                                        if ( intersection ) {

                                                                intersection.faceIndex = Math.floor( j / 3 ); // triangle number in non-indexed buffer semantics
                                                                intersection.face.materialIndex = group.materialIndex;
                                                                intersects.push( intersection );

                                                        }

                                                }

                                        }

                                } else {

                                        const start = Math.max( 0, drawRange.start );
                                        const end = Math.min( position.count, ( drawRange.start + drawRange.count ) );

                                        for ( let i = start, il = end; i < il; i += 3 ) {

                                                const a = i;
                                                const b = i + 1;
                                                const c = i + 2;

                                                intersection = checkBufferGeometryIntersection( this, material, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c );

                                                if ( intersection ) {

                                                        intersection.faceIndex = Math.floor( i / 3 ); // triangle number in non-indexed buffer semantics
                                                        intersects.push( intersection );

                                                }

                                        }

                                }

                        }

                } else if ( geometry.isGeometry ) {

                        console.error( 'THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

                }

        }

    } );

    function checkIntersection( object, material, raycaster, ray, pA, pB, pC, point ) {

        let intersect;

        if ( material.side === BackSide ) {

                intersect = ray.intersectTriangle( pC, pB, pA, true, point );

        } else {

                intersect = ray.intersectTriangle( pA, pB, pC, material.side !== DoubleSide, point );

        }

        if ( intersect === null ) return null;

        _intersectionPointWorld.copy( point );
        _intersectionPointWorld.applyMatrix4( object.matrixWorld );

        const distance = raycaster.ray.origin.distanceTo( _intersectionPointWorld );

        if ( distance < raycaster.near || distance > raycaster.far ) return null;

        return {
                distance: distance,
                point: _intersectionPointWorld.clone(),
                object: object
        };

    }

    function checkBufferGeometryIntersection( object, material, raycaster, ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c ) {

        _vA.fromBufferAttribute( position, a );
        _vB.fromBufferAttribute( position, b );
        _vC.fromBufferAttribute( position, c );

        const morphInfluences = object.morphTargetInfluences;

        if ( material.morphTargets && morphPosition && morphInfluences ) {

                _morphA.set( 0, 0, 0 );
                _morphB.set( 0, 0, 0 );
                _morphC.set( 0, 0, 0 );

                for ( let i = 0, il = morphPosition.length; i < il; i ++ ) {

                        const influence = morphInfluences[ i ];
                        const morphAttribute = morphPosition[ i ];

                        if ( influence === 0 ) continue;

                        _tempA.fromBufferAttribute( morphAttribute, a );
                        _tempB.fromBufferAttribute( morphAttribute, b );
                        _tempC.fromBufferAttribute( morphAttribute, c );

                        if ( morphTargetsRelative ) {

                                _morphA.addScaledVector( _tempA, influence );
                                _morphB.addScaledVector( _tempB, influence );
                                _morphC.addScaledVector( _tempC, influence );

                        } else {

                                _morphA.addScaledVector( _tempA.sub( _vA ), influence );
                                _morphB.addScaledVector( _tempB.sub( _vB ), influence );
                                _morphC.addScaledVector( _tempC.sub( _vC ), influence );

                        }

                }

                _vA.add( _morphA );
                _vB.add( _morphB );
                _vC.add( _morphC );

        }

        if ( object.isSkinnedMesh ) {

                object.boneTransform( a, _vA );
                object.boneTransform( b, _vB );
                object.boneTransform( c, _vC );

        }

        const intersection = checkIntersection( object, material, raycaster, ray, _vA, _vB, _vC, _intersectionPoint );

        if ( intersection ) {

                if ( uv ) {

                        _uvA.fromBufferAttribute( uv, a );
                        _uvB.fromBufferAttribute( uv, b );
                        _uvC.fromBufferAttribute( uv, c );

                        intersection.uv = Triangle.getUV( _intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2() );

                }

                if ( uv2 ) {

                        _uvA.fromBufferAttribute( uv2, a );
                        _uvB.fromBufferAttribute( uv2, b );
                        _uvC.fromBufferAttribute( uv2, c );

                        intersection.uv2 = Triangle.getUV( _intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2() );

                }

                const face = new Face3( a, b, c );
                Triangle.getNormal( _vA, _vB, _vC, face.normal );

                intersection.face = face;

        }

        return intersection;

    }

    class BoxGeometry extends BufferGeometry {

        constructor( width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1 ) {

                super();

                this.type = 'BoxGeometry';

                this.parameters = {
                        width: width,
                        height: height,
                        depth: depth,
                        widthSegments: widthSegments,
                        heightSegments: heightSegments,
                        depthSegments: depthSegments
                };

                const scope = this;

                // segments

                widthSegments = Math.floor( widthSegments );
                heightSegments = Math.floor( heightSegments );
                depthSegments = Math.floor( depthSegments );

                // buffers

                const indices = [];
                const vertices = [];
                const normals = [];
                const uvs = [];

                // helper variables

                let numberOfVertices = 0;
                let groupStart = 0;

                // build each side of the box geometry

                buildPlane( 'z', 'y', 'x', - 1, - 1, depth, height, width, depthSegments, heightSegments, 0 ); // px
                buildPlane( 'z', 'y', 'x', 1, - 1, depth, height, - width, depthSegments, heightSegments, 1 ); // nx
                buildPlane( 'x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2 ); // py
                buildPlane( 'x', 'z', 'y', 1, - 1, width, depth, - height, widthSegments, depthSegments, 3 ); // ny
                buildPlane( 'x', 'y', 'z', 1, - 1, width, height, depth, widthSegments, heightSegments, 4 ); // pz
                buildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth, widthSegments, heightSegments, 5 ); // nz

                // build geometry

                this.setIndex( indices );
                this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
                this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
                this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );

                function buildPlane( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {

                        const segmentWidth = width / gridX;
                        const segmentHeight = height / gridY;

                        const widthHalf = width / 2;
                        const heightHalf = height / 2;
                        const depthHalf = depth / 2;

                        const gridX1 = gridX + 1;
                        const gridY1 = gridY + 1;

                        let vertexCounter = 0;
                        let groupCount = 0;

                        const vector = new Vector3();

                        // generate vertices, normals and uvs

                        for ( let iy = 0; iy < gridY1; iy ++ ) {

                                const y = iy * segmentHeight - heightHalf;

                                for ( let ix = 0; ix < gridX1; ix ++ ) {

                                        const x = ix * segmentWidth - widthHalf;

                                        // set values to correct vector component

                                        vector[ u ] = x * udir;
                                        vector[ v ] = y * vdir;
                                        vector[ w ] = depthHalf;

                                        // now apply vector to vertex buffer

                                        vertices.push( vector.x, vector.y, vector.z );

                                        // set values to correct vector component

                                        vector[ u ] = 0;
                                        vector[ v ] = 0;
                                        vector[ w ] = depth > 0 ? 1 : - 1;

                                        // now apply vector to normal buffer

                                        normals.push( vector.x, vector.y, vector.z );

                                        // uvs

                                        uvs.push( ix / gridX );
                                        uvs.push( 1 - ( iy / gridY ) );

                                        // counters

                                        vertexCounter += 1;

                                }

                        }

                        // indices

                        // 1. you need three indices to draw a single face
                        // 2. a single segment consists of two faces
                        // 3. so we need to generate six (2*3) indices per segment

                        for ( let iy = 0; iy < gridY; iy ++ ) {

                                for ( let ix = 0; ix < gridX; ix ++ ) {

                                        const a = numberOfVertices + ix + gridX1 * iy;
                                        const b = numberOfVertices + ix + gridX1 * ( iy + 1 );
                                        const c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );
                                        const d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;

                                        // faces

                                        indices.push( a, b, d );
                                        indices.push( b, c, d );

                                        // increase counter

                                        groupCount += 6;

                                }

                        }

                        // add a group to the geometry. this will ensure multi material support

                        scope.addGroup( groupStart, groupCount, materialIndex );

                        // calculate new start value for groups

                        groupStart += groupCount;

                        // update total number of vertices

                        numberOfVertices += vertexCounter;

                }

        }

    }

    /**
     * Uniform Utilities
     */

    function cloneUniforms( src ) {

        const dst = {};

        for ( const u in src ) {

                dst[ u ] = {};

                for ( const p in src[ u ] ) {

                        const property = src[ u ][ p ];

                        if ( property && ( property.isColor ||
                                property.isMatrix3 || property.isMatrix4 ||
                                property.isVector2 || property.isVector3 || property.isVector4 ||
                                property.isTexture ) ) {

                                dst[ u ][ p ] = property.clone();

                        } else if ( Array.isArray( property ) ) {

                                dst[ u ][ p ] = property.slice();

                        } else {

                                dst[ u ][ p ] = property;

                        }

                }

        }

        return dst;

    }

    function mergeUniforms( uniforms ) {

        const merged = {};

        for ( let u = 0; u < uniforms.length; u ++ ) {

                const tmp = cloneUniforms( uniforms[ u ] );

                for ( const p in tmp ) {

                        merged[ p ] = tmp[ p ];

                }

        }

        return merged;

    }

    // Legacy

    const UniformsUtils = { clone: cloneUniforms, merge: mergeUniforms };

    var default_vertex = "void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";

    var default_fragment = "void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}";

    /**
     * parameters = {
     *  defines: { "label" : "value" },
     *  uniforms: { "parameter1": { value: 1.0 }, "parameter2": { value2: 2 } },
     *
     *  fragmentShader: <string>,
     *  vertexShader: <string>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>,
     *
     *  lights: <bool>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function ShaderMaterial( parameters ) {

        Material.call( this );

        this.type = 'ShaderMaterial';

        this.defines = {};
        this.uniforms = {};

        this.vertexShader = default_vertex;
        this.fragmentShader = default_fragment;

        this.linewidth = 1;

        this.wireframe = false;
        this.wireframeLinewidth = 1;

        this.fog = false; // set to use scene fog
        this.lights = false; // set to use scene lights
        this.clipping = false; // set to use user-defined clipping planes

        this.skinning = false; // set to use skinning attribute streams
        this.morphTargets = false; // set to use morph targets
        this.morphNormals = false; // set to use morph normals

        this.extensions = {
                derivatives: false, // set to use derivatives
                fragDepth: false, // set to use fragment depth values
                drawBuffers: false, // set to use draw buffers
                shaderTextureLOD: false // set to use shader texture LOD
        };

        // When rendered geometry doesn't include these attributes but the material does,
        // use these default values in WebGL. This avoids errors when buffer data is missing.
        this.defaultAttributeValues = {
                'color': [ 1, 1, 1 ],
                'uv': [ 0, 0 ],
                'uv2': [ 0, 0 ]
        };

        this.index0AttributeName = undefined;
        this.uniformsNeedUpdate = false;

        this.glslVersion = null;

        if ( parameters !== undefined ) {

                if ( parameters.attributes !== undefined ) {

                        console.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' );

                }

                this.setValues( parameters );

        }

    }

    ShaderMaterial.prototype = Object.create( Material.prototype );
    ShaderMaterial.prototype.constructor = ShaderMaterial;

    ShaderMaterial.prototype.isShaderMaterial = true;

    ShaderMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.fragmentShader = source.fragmentShader;
        this.vertexShader = source.vertexShader;

        this.uniforms = cloneUniforms( source.uniforms );

        this.defines = Object.assign( {}, source.defines );

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;

        this.lights = source.lights;
        this.clipping = source.clipping;

        this.skinning = source.skinning;

        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        this.extensions = Object.assign( {}, source.extensions );

        this.glslVersion = source.glslVersion;

        return this;

    };

    ShaderMaterial.prototype.toJSON = function ( meta ) {

        const data = Material.prototype.toJSON.call( this, meta );

        data.glslVersion = this.glslVersion;
        data.uniforms = {};

        for ( const name in this.uniforms ) {

                const uniform = this.uniforms[ name ];
                const value = uniform.value;

                if ( value && value.isTexture ) {

                        data.uniforms[ name ] = {
                                type: 't',
                                value: value.toJSON( meta ).uuid
                        };

                } else if ( value && value.isColor ) {

                        data.uniforms[ name ] = {
                                type: 'c',
                                value: value.getHex()
                        };

                } else if ( value && value.isVector2 ) {

                        data.uniforms[ name ] = {
                                type: 'v2',
                                value: value.toArray()
                        };

                } else if ( value && value.isVector3 ) {

                        data.uniforms[ name ] = {
                                type: 'v3',
                                value: value.toArray()
                        };

                } else if ( value && value.isVector4 ) {

                        data.uniforms[ name ] = {
                                type: 'v4',
                                value: value.toArray()
                        };

                } else if ( value && value.isMatrix3 ) {

                        data.uniforms[ name ] = {
                                type: 'm3',
                                value: value.toArray()
                        };

                } else if ( value && value.isMatrix4 ) {

                        data.uniforms[ name ] = {
                                type: 'm4',
                                value: value.toArray()
                        };

                } else {

                        data.uniforms[ name ] = {
                                value: value
                        };

                        // note: the array variants v2v, v3v, v4v, m4v and tv are not supported so far

                }

        }

        if ( Object.keys( this.defines ).length > 0 ) data.defines = this.defines;

        data.vertexShader = this.vertexShader;
        data.fragmentShader = this.fragmentShader;

        const extensions = {};

        for ( const key in this.extensions ) {

                if ( this.extensions[ key ] === true ) extensions[ key ] = true;

        }

        if ( Object.keys( extensions ).length > 0 ) data.extensions = extensions;

        return data;

    };

    function Camera$1() {

        Object3D.call( this );

        this.type = 'Camera';

        this.matrixWorldInverse = new Matrix4();

        this.projectionMatrix = new Matrix4();
        this.projectionMatrixInverse = new Matrix4();

    }

    Camera$1.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Camera$1,

        isCamera: true,

        copy: function ( source, recursive ) {

                Object3D.prototype.copy.call( this, source, recursive );

                this.matrixWorldInverse.copy( source.matrixWorldInverse );

                this.projectionMatrix.copy( source.projectionMatrix );
                this.projectionMatrixInverse.copy( source.projectionMatrixInverse );

                return this;

        },

        getWorldDirection: function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Camera: .getWorldDirection() target is now required' );
                        target = new Vector3();

                }

                this.updateWorldMatrix( true, false );

                const e = this.matrixWorld.elements;

                return target.set( - e[ 8 ], - e[ 9 ], - e[ 10 ] ).normalize();

        },

        updateMatrixWorld: function ( force ) {

                Object3D.prototype.updateMatrixWorld.call( this, force );

                this.matrixWorldInverse.copy( this.matrixWorld ).invert();

        },

        updateWorldMatrix: function ( updateParents, updateChildren ) {

                Object3D.prototype.updateWorldMatrix.call( this, updateParents, updateChildren );

                this.matrixWorldInverse.copy( this.matrixWorld ).invert();

        },

        clone: function () {

                return new this.constructor().copy( this );

        }

    } );

    function PerspectiveCamera( fov = 50, aspect = 1, near = 0.1, far = 2000 ) {

        Camera$1.call( this );

        this.type = 'PerspectiveCamera';

        this.fov = fov;
        this.zoom = 1;

        this.near = near;
        this.far = far;
        this.focus = 10;

        this.aspect = aspect;
        this.view = null;

        this.filmGauge = 35;    // width of the film (default in millimeters)
        this.filmOffset = 0;    // horizontal film offset (same unit as gauge)

        this.updateProjectionMatrix();

    }

    PerspectiveCamera.prototype = Object.assign( Object.create( Camera$1.prototype ), {

        constructor: PerspectiveCamera,

        isPerspectiveCamera: true,

        copy: function ( source, recursive ) {

                Camera$1.prototype.copy.call( this, source, recursive );

                this.fov = source.fov;
                this.zoom = source.zoom;

                this.near = source.near;
                this.far = source.far;
                this.focus = source.focus;

                this.aspect = source.aspect;
                this.view = source.view === null ? null : Object.assign( {}, source.view );

                this.filmGauge = source.filmGauge;
                this.filmOffset = source.filmOffset;

                return this;

        },

        /**
         * Sets the FOV by focal length in respect to the current .filmGauge.
         *
         * The default film gauge is 35, so that the focal length can be specified for
         * a 35mm (full frame) camera.
         *
         * Values for focal length and film gauge must have the same unit.
         */
        setFocalLength: function ( focalLength ) {

                /** see {@link http://www.bobatkins.com/photography/technical/field_of_view.html} */
                const vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;

                this.fov = MathUtils.RAD2DEG * 2 * Math.atan( vExtentSlope );
                this.updateProjectionMatrix();

        },

        /**
         * Calculates the focal length from the current .fov and .filmGauge.
         */
        getFocalLength: function () {

                const vExtentSlope = Math.tan( MathUtils.DEG2RAD * 0.5 * this.fov );

                return 0.5 * this.getFilmHeight() / vExtentSlope;

        },

        getEffectiveFOV: function () {

                return MathUtils.RAD2DEG * 2 * Math.atan(
                        Math.tan( MathUtils.DEG2RAD * 0.5 * this.fov ) / this.zoom );

        },

        getFilmWidth: function () {

                // film not completely covered in portrait format (aspect < 1)
                return this.filmGauge * Math.min( this.aspect, 1 );

        },

        getFilmHeight: function () {

                // film not completely covered in landscape format (aspect > 1)
                return this.filmGauge / Math.max( this.aspect, 1 );

        },

        /**
         * Sets an offset in a larger frustum. This is useful for multi-window or
         * multi-monitor/multi-machine setups.
         *
         * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
         * the monitors are in grid like this
         *
         *   +---+---+---+
         *   | A | B | C |
         *   +---+---+---+
         *   | D | E | F |
         *   +---+---+---+
         *
         * then for each monitor you would call it like this
         *
         *   const w = 1920;
         *   const h = 1080;
         *   const fullWidth = w * 3;
         *   const fullHeight = h * 2;
         *
         *   --A--
         *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
         *   --B--
         *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
         *   --C--
         *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
         *   --D--
         *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
         *   --E--
         *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
         *   --F--
         *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
         *
         *   Note there is no reason monitors have to be the same size or in a grid.
         */
        setViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {

                this.aspect = fullWidth / fullHeight;

                if ( this.view === null ) {

                        this.view = {
                                enabled: true,
                                fullWidth: 1,
                                fullHeight: 1,
                                offsetX: 0,
                                offsetY: 0,
                                width: 1,
                                height: 1
                        };

                }

                this.view.enabled = true;
                this.view.fullWidth = fullWidth;
                this.view.fullHeight = fullHeight;
                this.view.offsetX = x;
                this.view.offsetY = y;
                this.view.width = width;
                this.view.height = height;

                this.updateProjectionMatrix();

        },

        clearViewOffset: function () {

                if ( this.view !== null ) {

                        this.view.enabled = false;

                }

                this.updateProjectionMatrix();

        },

        updateProjectionMatrix: function () {

                const near = this.near;
                let top = near * Math.tan( MathUtils.DEG2RAD * 0.5 * this.fov ) / this.zoom;
                let height = 2 * top;
                let width = this.aspect * height;
                let left = - 0.5 * width;
                const view = this.view;

                if ( this.view !== null && this.view.enabled ) {

                        const fullWidth = view.fullWidth,
                                fullHeight = view.fullHeight;

                        left += view.offsetX * width / fullWidth;
                        top -= view.offsetY * height / fullHeight;
                        width *= view.width / fullWidth;
                        height *= view.height / fullHeight;

                }

                const skew = this.filmOffset;
                if ( skew !== 0 ) left += near * skew / this.getFilmWidth();

                this.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far );

                this.projectionMatrixInverse.copy( this.projectionMatrix ).invert();

        },

        toJSON: function ( meta ) {

                const data = Object3D.prototype.toJSON.call( this, meta );

                data.object.fov = this.fov;
                data.object.zoom = this.zoom;

                data.object.near = this.near;
                data.object.far = this.far;
                data.object.focus = this.focus;

                data.object.aspect = this.aspect;

                if ( this.view !== null ) data.object.view = Object.assign( {}, this.view );

                data.object.filmGauge = this.filmGauge;
                data.object.filmOffset = this.filmOffset;

                return data;

        }

    } );

    const fov = 90, aspect = 1;

    function CubeCamera( near, far, renderTarget ) {

        Object3D.call( this );

        this.type = 'CubeCamera';

        if ( renderTarget.isWebGLCubeRenderTarget !== true ) {

                console.error( 'THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.' );
                return;

        }

        this.renderTarget = renderTarget;

        const cameraPX = new PerspectiveCamera( fov, aspect, near, far );
        cameraPX.layers = this.layers;
        cameraPX.up.set( 0, - 1, 0 );
        cameraPX.lookAt( new Vector3( 1, 0, 0 ) );
        this.add( cameraPX );

        const cameraNX = new PerspectiveCamera( fov, aspect, near, far );
        cameraNX.layers = this.layers;
        cameraNX.up.set( 0, - 1, 0 );
        cameraNX.lookAt( new Vector3( - 1, 0, 0 ) );
        this.add( cameraNX );

        const cameraPY = new PerspectiveCamera( fov, aspect, near, far );
        cameraPY.layers = this.layers;
        cameraPY.up.set( 0, 0, 1 );
        cameraPY.lookAt( new Vector3( 0, 1, 0 ) );
        this.add( cameraPY );

        const cameraNY = new PerspectiveCamera( fov, aspect, near, far );
        cameraNY.layers = this.layers;
        cameraNY.up.set( 0, 0, - 1 );
        cameraNY.lookAt( new Vector3( 0, - 1, 0 ) );
        this.add( cameraNY );

        const cameraPZ = new PerspectiveCamera( fov, aspect, near, far );
        cameraPZ.layers = this.layers;
        cameraPZ.up.set( 0, - 1, 0 );
        cameraPZ.lookAt( new Vector3( 0, 0, 1 ) );
        this.add( cameraPZ );

        const cameraNZ = new PerspectiveCamera( fov, aspect, near, far );
        cameraNZ.layers = this.layers;
        cameraNZ.up.set( 0, - 1, 0 );
        cameraNZ.lookAt( new Vector3( 0, 0, - 1 ) );
        this.add( cameraNZ );

        this.update = function ( renderer, scene ) {

                if ( this.parent === null ) this.updateMatrixWorld();

                const currentXrEnabled = renderer.xr.enabled;
                const currentRenderTarget = renderer.getRenderTarget();

                renderer.xr.enabled = false;

                const generateMipmaps = renderTarget.texture.generateMipmaps;

                renderTarget.texture.generateMipmaps = false;

                renderer.setRenderTarget( renderTarget, 0 );
                renderer.render( scene, cameraPX );

                renderer.setRenderTarget( renderTarget, 1 );
                renderer.render( scene, cameraNX );

                renderer.setRenderTarget( renderTarget, 2 );
                renderer.render( scene, cameraPY );

                renderer.setRenderTarget( renderTarget, 3 );
                renderer.render( scene, cameraNY );

                renderer.setRenderTarget( renderTarget, 4 );
                renderer.render( scene, cameraPZ );

                renderTarget.texture.generateMipmaps = generateMipmaps;

                renderer.setRenderTarget( renderTarget, 5 );
                renderer.render( scene, cameraNZ );

                renderer.setRenderTarget( currentRenderTarget );

                renderer.xr.enabled = currentXrEnabled;

        };

    }

    CubeCamera.prototype = Object.create( Object3D.prototype );
    CubeCamera.prototype.constructor = CubeCamera;

    function CubeTexture( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {

        images = images !== undefined ? images : [];
        mapping = mapping !== undefined ? mapping : CubeReflectionMapping;
        format = format !== undefined ? format : RGBFormat;

        Texture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );

        this.flipY = false;

        // Why CubeTexture._needsFlipEnvMap is necessary:
        //
        // By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)
        // in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,
        // in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.

        // three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
        // and the flag _needsFlipEnvMap controls this conversion. The flip is not required (and thus _needsFlipEnvMap is set to false)
        // when using WebGLCubeRenderTarget.texture as a cube texture.

        this._needsFlipEnvMap = true;

    }

    CubeTexture.prototype = Object.create( Texture.prototype );
    CubeTexture.prototype.constructor = CubeTexture;

    CubeTexture.prototype.isCubeTexture = true;

    Object.defineProperty( CubeTexture.prototype, 'images', {

        get: function () {

                return this.image;

        },

        set: function ( value ) {

                this.image = value;

        }

    } );

    class WebGLCubeRenderTarget extends WebGLRenderTarget {

        constructor( size, options, dummy ) {

                if ( Number.isInteger( options ) ) {

                        console.warn( 'THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )' );

                        options = dummy;

                }

                super( size, size, options );

                Object.defineProperty( this, 'isWebGLCubeRenderTarget', { value: true } );

                options = options || {};

                this.texture = new CubeTexture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );

                this.texture._needsFlipEnvMap = false;

        }

        fromEquirectangularTexture( renderer, texture ) {

                this.texture.type = texture.type;
                this.texture.format = RGBAFormat; // see #18859
                this.texture.encoding = texture.encoding;

                this.texture.generateMipmaps = texture.generateMipmaps;
                this.texture.minFilter = texture.minFilter;
                this.texture.magFilter = texture.magFilter;

                const shader = {

                        uniforms: {
                                tEquirect: { value: null },
                        },

                        vertexShader: /* glsl */`

                                varying vec3 vWorldDirection;

                                vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

                                        return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

                                }

                                void main() {

                                        vWorldDirection = transformDirection( position, modelMatrix );

                                        #include <begin_vertex>
                                        #include <project_vertex>

                                }
                        `,

                        fragmentShader: /* glsl */`

                                uniform sampler2D tEquirect;

                                varying vec3 vWorldDirection;

                                #include <common>

                                void main() {

                                        vec3 direction = normalize( vWorldDirection );

                                        vec2 sampleUV = equirectUv( direction );

                                        gl_FragColor = texture2D( tEquirect, sampleUV );

                                }
                        `
                };

                const geometry = new BoxGeometry( 5, 5, 5 );

                const material = new ShaderMaterial( {

                        name: 'CubemapFromEquirect',

                        uniforms: cloneUniforms( shader.uniforms ),
                        vertexShader: shader.vertexShader,
                        fragmentShader: shader.fragmentShader,
                        side: BackSide,
                        blending: NoBlending

                } );

                material.uniforms.tEquirect.value = texture;

                const mesh = new Mesh( geometry, material );

                const currentMinFilter = texture.minFilter;

                // Avoid blurred poles
                if ( texture.minFilter === LinearMipmapLinearFilter ) texture.minFilter = LinearFilter;

                const camera = new CubeCamera( 1, 10, this );
                camera.update( renderer, mesh );

                texture.minFilter = currentMinFilter;

                mesh.geometry.dispose();
                mesh.material.dispose();

                return this;

        }

        clear( renderer, color, depth, stencil ) {

                const currentRenderTarget = renderer.getRenderTarget();

                for ( let i = 0; i < 6; i ++ ) {

                        renderer.setRenderTarget( this, i );

                        renderer.clear( color, depth, stencil );

                }

                renderer.setRenderTarget( currentRenderTarget );

        }

    }

    function DataTexture( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {

        Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );

        this.image = { data: data || null, width: width || 1, height: height || 1 };

        this.magFilter = magFilter !== undefined ? magFilter : NearestFilter;
        this.minFilter = minFilter !== undefined ? minFilter : NearestFilter;

        this.generateMipmaps = false;
        this.flipY = false;
        this.unpackAlignment = 1;

        this.needsUpdate = true;

    }

    DataTexture.prototype = Object.create( Texture.prototype );
    DataTexture.prototype.constructor = DataTexture;

    DataTexture.prototype.isDataTexture = true;

    const _sphere$1 = /*@__PURE__*/ new Sphere();
    const _vector$5 = /*@__PURE__*/ new Vector3();

    class Frustum {

        constructor( p0, p1, p2, p3, p4, p5 ) {

                this.planes = [

                        ( p0 !== undefined ) ? p0 : new Plane(),
                        ( p1 !== undefined ) ? p1 : new Plane(),
                        ( p2 !== undefined ) ? p2 : new Plane(),
                        ( p3 !== undefined ) ? p3 : new Plane(),
                        ( p4 !== undefined ) ? p4 : new Plane(),
                        ( p5 !== undefined ) ? p5 : new Plane()

                ];

        }

        set( p0, p1, p2, p3, p4, p5 ) {

                const planes = this.planes;

                planes[ 0 ].copy( p0 );
                planes[ 1 ].copy( p1 );
                planes[ 2 ].copy( p2 );
                planes[ 3 ].copy( p3 );
                planes[ 4 ].copy( p4 );
                planes[ 5 ].copy( p5 );

                return this;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( frustum ) {

                const planes = this.planes;

                for ( let i = 0; i < 6; i ++ ) {

                        planes[ i ].copy( frustum.planes[ i ] );

                }

                return this;

        }

        setFromProjectionMatrix( m ) {

                const planes = this.planes;
                const me = m.elements;
                const me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];
                const me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];
                const me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];
                const me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];

                planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();
                planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();
                planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();
                planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();
                planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();
                planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();

                return this;

        }

        intersectsObject( object ) {

                const geometry = object.geometry;

                if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();

                _sphere$1.copy( geometry.boundingSphere ).applyMatrix4( object.matrixWorld );

                return this.intersectsSphere( _sphere$1 );

        }

        intersectsSprite( sprite ) {

                _sphere$1.center.set( 0, 0, 0 );
                _sphere$1.radius = 0.7071067811865476;
                _sphere$1.applyMatrix4( sprite.matrixWorld );

                return this.intersectsSphere( _sphere$1 );

        }

        intersectsSphere( sphere ) {

                const planes = this.planes;
                const center = sphere.center;
                const negRadius = - sphere.radius;

                for ( let i = 0; i < 6; i ++ ) {

                        const distance = planes[ i ].distanceToPoint( center );

                        if ( distance < negRadius ) {

                                return false;

                        }

                }

                return true;

        }

        intersectsBox( box ) {

                const planes = this.planes;

                for ( let i = 0; i < 6; i ++ ) {

                        const plane = planes[ i ];

                        // corner at max distance

                        _vector$5.x = plane.normal.x > 0 ? box.max.x : box.min.x;
                        _vector$5.y = plane.normal.y > 0 ? box.max.y : box.min.y;
                        _vector$5.z = plane.normal.z > 0 ? box.max.z : box.min.z;

                        if ( plane.distanceToPoint( _vector$5 ) < 0 ) {

                                return false;

                        }

                }

                return true;

        }

        containsPoint( point ) {

                const planes = this.planes;

                for ( let i = 0; i < 6; i ++ ) {

                        if ( planes[ i ].distanceToPoint( point ) < 0 ) {

                                return false;

                        }

                }

                return true;

        }

    }

    function WebGLAnimation() {

        let context = null;
        let isAnimating = false;
        let animationLoop = null;
        let requestId = null;

        function onAnimationFrame( time, frame ) {

                animationLoop( time, frame );

                requestId = context.requestAnimationFrame( onAnimationFrame );

        }

        return {

                start: function () {

                        if ( isAnimating === true ) return;
                        if ( animationLoop === null ) return;

                        requestId = context.requestAnimationFrame( onAnimationFrame );

                        isAnimating = true;

                },

                stop: function () {

                        context.cancelAnimationFrame( requestId );

                        isAnimating = false;

                },

                setAnimationLoop: function ( callback ) {

                        animationLoop = callback;

                },

                setContext: function ( value ) {

                        context = value;

                }

        };

    }

    function WebGLAttributes( gl, capabilities ) {

        const isWebGL2 = capabilities.isWebGL2;

        const buffers = new WeakMap();

        function createBuffer( attribute, bufferType ) {

                const array = attribute.array;
                const usage = attribute.usage;

                const buffer = gl.createBuffer();

                gl.bindBuffer( bufferType, buffer );
                gl.bufferData( bufferType, array, usage );

                attribute.onUploadCallback();

                let type = 5126;

                if ( array instanceof Float32Array ) {

                        type = 5126;

                } else if ( array instanceof Float64Array ) {

                        console.warn( 'THREE.WebGLAttributes: Unsupported data buffer format: Float64Array.' );

                } else if ( array instanceof Uint16Array ) {

                        if ( attribute.isFloat16BufferAttribute ) {

                                if ( isWebGL2 ) {

                                        type = 5131;

                                } else {

                                        console.warn( 'THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2.' );

                                }

                        } else {

                                type = 5123;

                        }

                } else if ( array instanceof Int16Array ) {

                        type = 5122;

                } else if ( array instanceof Uint32Array ) {

                        type = 5125;

                } else if ( array instanceof Int32Array ) {

                        type = 5124;

                } else if ( array instanceof Int8Array ) {

                        type = 5120;

                } else if ( array instanceof Uint8Array ) {

                        type = 5121;

                }

                return {
                        buffer: buffer,
                        type: type,
                        bytesPerElement: array.BYTES_PER_ELEMENT,
                        version: attribute.version
                };

        }

        function updateBuffer( buffer, attribute, bufferType ) {

                const array = attribute.array;
                const updateRange = attribute.updateRange;

                gl.bindBuffer( bufferType, buffer );

                if ( updateRange.count === - 1 ) {

                        // Not using update ranges

                        gl.bufferSubData( bufferType, 0, array );

                } else {

                        if ( isWebGL2 ) {

                                gl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,
                                        array, updateRange.offset, updateRange.count );

                        } else {

                                gl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,
                                        array.subarray( updateRange.offset, updateRange.offset + updateRange.count ) );

                        }

                        updateRange.count = - 1; // reset range

                }

        }

        //

        function get( attribute ) {

                if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;

                return buffers.get( attribute );

        }

        function remove( attribute ) {

                if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;

                const data = buffers.get( attribute );

                if ( data ) {

                        gl.deleteBuffer( data.buffer );

                        buffers.delete( attribute );

                }

        }

        function update( attribute, bufferType ) {

                if ( attribute.isGLBufferAttribute ) {

                        const cached = buffers.get( attribute );

                        if ( ! cached || cached.version < attribute.version ) {

                                buffers.set( attribute, {
                                        buffer: attribute.buffer,
                                        type: attribute.type,
                                        bytesPerElement: attribute.elementSize,
                                        version: attribute.version
                                } );

                        }

                        return;

                }

                if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;

                const data = buffers.get( attribute );

                if ( data === undefined ) {

                        buffers.set( attribute, createBuffer( attribute, bufferType ) );

                } else if ( data.version < attribute.version ) {

                        updateBuffer( data.buffer, attribute, bufferType );

                        data.version = attribute.version;

                }

        }

        return {

                get: get,
                remove: remove,
                update: update

        };

    }

    class PlaneGeometry extends BufferGeometry {

        constructor( width = 1, height = 1, widthSegments = 1, heightSegments = 1 ) {

                super();
                this.type = 'PlaneGeometry';

                this.parameters = {
                        width: width,
                        height: height,
                        widthSegments: widthSegments,
                        heightSegments: heightSegments
                };

                const width_half = width / 2;
                const height_half = height / 2;

                const gridX = Math.floor( widthSegments );
                const gridY = Math.floor( heightSegments );

                const gridX1 = gridX + 1;
                const gridY1 = gridY + 1;

                const segment_width = width / gridX;
                const segment_height = height / gridY;

                //

                const indices = [];
                const vertices = [];
                const normals = [];
                const uvs = [];

                for ( let iy = 0; iy < gridY1; iy ++ ) {

                        const y = iy * segment_height - height_half;

                        for ( let ix = 0; ix < gridX1; ix ++ ) {

                                const x = ix * segment_width - width_half;

                                vertices.push( x, - y, 0 );

                                normals.push( 0, 0, 1 );

                                uvs.push( ix / gridX );
                                uvs.push( 1 - ( iy / gridY ) );

                        }

                }

                for ( let iy = 0; iy < gridY; iy ++ ) {

                        for ( let ix = 0; ix < gridX; ix ++ ) {

                                const a = ix + gridX1 * iy;
                                const b = ix + gridX1 * ( iy + 1 );
                                const c = ( ix + 1 ) + gridX1 * ( iy + 1 );
                                const d = ( ix + 1 ) + gridX1 * iy;

                                indices.push( a, b, d );
                                indices.push( b, c, d );

                        }

                }

                this.setIndex( indices );
                this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
                this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
                this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );

        }

    }

    var alphamap_fragment = "#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif";

    var alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";

    var alphatest_fragment = "#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif";

    var aomap_fragment = "#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif";

    var aomap_pars_fragment = "#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif";

    var begin_vertex = "vec3 transformed = vec3( position );";

    var beginnormal_vertex = "vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif";

    var bsdfs = "vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n#else\n\tif( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr = max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + viewDir );\n\tfloat dotNL = saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F = F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss = F * brdf.x + brdf.y;\n\tfloat Ess = brdf.x + brdf.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha = 1.0 / roughness;\n\tfloat cos2h = NoH * NoH;\n\tfloat sin2h = max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N = geometry.normal;\n\tvec3 V = geometry.viewDir;\n\tvec3 H = normalize( V + L );\n\tfloat dotNH = saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\n}\n#endif";

    var bumpmap_pars_fragment = "#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 );\n\t\tfDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif";

    var clipping_planes_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif";

    var clipping_planes_pars_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif";

    var clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif";

    var clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif";

    var color_fragment = "#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif";

    var color_pars_fragment = "#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif";

    var color_pars_vertex = "#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif";

    var color_vertex = "#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor.xyz *= color.xyz;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif";

    var common$1 = "#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract(sin(sn) * c);\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}";

    var cube_uv_reflection_fragment = "#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 );\n\t\tvec2 f = fract( uv );\n\t\tuv += 0.5 - f;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\tvec3 tl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x += texelSize;\n\t\tvec3 tr = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.y += texelSize;\n\t\tvec3 br = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x -= texelSize;\n\t\tvec3 bl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tvec3 tm = mix( tl, tr, f.x );\n\t\tvec3 bm = mix( bl, br, f.x );\n\t\treturn mix( tm, bm, f.y );\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif";

    var defaultnormal_vertex = "vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif";

    var displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif";

    var displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif";

    var emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif";

    var emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif";

    var encodings_fragment = "gl_FragColor = linearToOutputTexel( gl_FragColor );";

    var encodings_pars_fragment = "\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat M = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat D = max( maxRange / maxRGB, 1.0 );\n\tD = clamp( floor( D ) / 255.0, 0.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value ) {\n\tvec3 Xp_Y_XYZp = cLogLuvM * value.rgb;\n\tXp_Y_XYZp = max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract( Le );\n\tvResult.z = ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}";

    var envmap_fragment = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifndef ENVMAP_TYPE_CUBE_UV\n\t\tenvColor = envMapTexelToLinear( envColor );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif";

    var envmap_common_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform int maxMipLevel;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif";

    var envmap_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif";

    var envmap_pars_vertex = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif";

    var envmap_vertex = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif";

    var fog_vertex = "#ifdef USE_FOG\n\tfogDepth = - mvPosition.z;\n#endif";

    var fog_pars_vertex = "#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif";

    var fog_fragment = "#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif";

    var fog_pars_fragment = "#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif";

    var gradientmap_pars_fragment = "#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn texture2D( gradientMap, coord ).rgb;\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}";

    var lightmap_fragment = "#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\treflectedLight.indirectDiffuse += PI * lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n#endif";

    var lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif";

    var lights_lambert_vertex = "vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif";

    var lights_pars_begin = "uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {\n\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif";

    var envmap_physical_pars_fragment = "#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor = vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar = float( maxMIPLevel );\n\t\tfloat sigma = PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel = maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( -viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel = getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif";

    var lights_toon_fragment = "ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;";

    var lights_toon_pars_fragment = "varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)";

    var lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;";

    var lights_phong_pars_fragment = "varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)";

    var lights_physical_fragment = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.specularRoughness = max( roughnessFactor, 0.0525 );material.specularRoughness += geometryRoughness;\nmaterial.specularRoughness = min( material.specularRoughness, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheen;\n#endif";

    var lights_physical_pars_fragment = "struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat specularRoughness;\n\tvec3 specularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *= PI;\n\t\t#endif\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular += ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNV = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular += clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL = ccDotNV;\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\tfloat clearcoatInv = 1.0 - clearcoatDHR;\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += clearcoatInv * radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}";

    var lights_fragment_begin = "\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif";

    var lights_fragment_maps = "#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\n\t#endif\n#endif";

    var lights_fragment_end = "#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif";

    var logdepthbuf_fragment = "#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif";

    var logdepthbuf_pars_fragment = "#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif";

    var logdepthbuf_pars_vertex = "#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif";

    var logdepthbuf_vertex = "#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif";

    var map_fragment = "#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif";

    var map_pars_fragment = "#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif";

    var map_particle_fragment = "#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tvec4 mapTexel = texture2D( map, uv );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif";

    var map_particle_pars_fragment = "#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";

    var metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif";

    var metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif";

    var morphnormal_vertex = "#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n#endif";

    var morphtarget_pars_vertex = "#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifndef USE_MORPHNORMALS\n\t\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\t\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif";

    var morphtarget_vertex = "#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t#endif\n#endif";

    var normal_fragment_begin = "#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent = bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;";

    var normal_fragment_maps = "#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( -vViewPosition, normal, mapN );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif";

    var normalmap_pars_fragment = "#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tfloat scale = sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S = normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T = normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N = normalize( surf_norm );\n\t\tmat3 tsn = mat3( S, T, N );\n\t\tmapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif";

    var clearcoat_normal_fragment_begin = "#ifdef CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif";

    var clearcoat_normal_fragment_maps = "#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN );\n\t#endif\n#endif";

    var clearcoat_pars_fragment = "#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif";

    var packing = "vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ));\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}";

    var premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif";

    var project_vertex = "vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;";

    var dithering_fragment = "#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif";

    var dithering_pars_fragment = "#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif";

    var roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif";

    var roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif";

    var shadowmap_pars_fragment = "#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif";

    var shadowmap_pars_vertex = "#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif";

    var shadowmap_vertex = "#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif";

    var shadowmask_pars_fragment = "float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}";

    var skinbase_vertex = "#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";

    var skinning_pars_vertex = "#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif";

    var skinning_vertex = "#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif";

    var skinnormal_vertex = "#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif";

    var specularmap_fragment = "float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif";

    var specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif";

    var tonemapping_fragment = "#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif";

    var tonemapping_pars_fragment = "#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }";

    var transmissionmap_fragment = "#ifdef USE_TRANSMISSIONMAP\n\ttotalTransmission *= texture2D( transmissionMap, vUv ).r;\n#endif";

    var transmissionmap_pars_fragment = "#ifdef USE_TRANSMISSIONMAP\n\tuniform sampler2D transmissionMap;\n#endif";

    var uv_pars_fragment = "#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif";

    var uv_pars_vertex = "#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif";

    var uv_vertex = "#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif";

    var uv2_pars_fragment = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif";

    var uv2_pars_vertex = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif";

    var uv2_vertex = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif";

    var worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif";

    var background_frag = "uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}";

    var background_vert = "varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}";

    var cube_frag = "#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}";

    var cube_vert = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";

    var depth_frag = "#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}";

    var depth_vert = "#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}";

    var distanceRGBA_frag = "#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}";

    var distanceRGBA_vert = "#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}";

    var equirect_frag = "uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tvec4 texColor = texture2D( tEquirect, sampleUV );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}";

    var equirect_vert = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}";

    var linedashed_frag = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";

    var linedashed_vert = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";

    var meshbasic_frag = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";

    var meshbasic_vert = "#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}";

    var meshlambert_frag = "uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";

    var meshlambert_vert = "#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";

    var meshmatcap_frag = "#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t\tmatcapColor = matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor = vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";

    var meshmatcap_vert = "#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#ifndef FLAT_SHADED\n\t\tvNormal = normalize( transformedNormal );\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}";

    var meshtoon_frag = "#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";

    var meshtoon_vert = "#define TOON\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";

    var meshphong_frag = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";

    var meshphong_vert = "#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";

    var meshphysical_frag = "#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSMISSION\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSMISSION\n\tuniform float transmission;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <transmissionmap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#ifdef TRANSMISSION\n\t\tfloat totalTransmission = transmission;\n\t#endif\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <transmissionmap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSMISSION\n\t\tdiffuseColor.a *= mix( saturate( 1. - totalTransmission + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) ), 1.0, metalness );\n\t#endif\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";

    var meshphysical_vert = "#define STANDARD\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";

    var normal_frag = "#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}";

    var normal_vert = "#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}";

    var points_frag = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";

    var points_vert = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}";

    var shadow_frag = "uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}";

    var shadow_vert = "#include <common>\n#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";

    var sprite_frag = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}";

    var sprite_vert = "uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";

    const ShaderChunk = {
        alphamap_fragment: alphamap_fragment,
        alphamap_pars_fragment: alphamap_pars_fragment,
        alphatest_fragment: alphatest_fragment,
        aomap_fragment: aomap_fragment,
        aomap_pars_fragment: aomap_pars_fragment,
        begin_vertex: begin_vertex,
        beginnormal_vertex: beginnormal_vertex,
        bsdfs: bsdfs,
        bumpmap_pars_fragment: bumpmap_pars_fragment,
        clipping_planes_fragment: clipping_planes_fragment,
        clipping_planes_pars_fragment: clipping_planes_pars_fragment,
        clipping_planes_pars_vertex: clipping_planes_pars_vertex,
        clipping_planes_vertex: clipping_planes_vertex,
        color_fragment: color_fragment,
        color_pars_fragment: color_pars_fragment,
        color_pars_vertex: color_pars_vertex,
        color_vertex: color_vertex,
        common: common$1,
        cube_uv_reflection_fragment: cube_uv_reflection_fragment,
        defaultnormal_vertex: defaultnormal_vertex,
        displacementmap_pars_vertex: displacementmap_pars_vertex,
        displacementmap_vertex: displacementmap_vertex,
        emissivemap_fragment: emissivemap_fragment,
        emissivemap_pars_fragment: emissivemap_pars_fragment,
        encodings_fragment: encodings_fragment,
        encodings_pars_fragment: encodings_pars_fragment,
        envmap_fragment: envmap_fragment,
        envmap_common_pars_fragment: envmap_common_pars_fragment,
        envmap_pars_fragment: envmap_pars_fragment,
        envmap_pars_vertex: envmap_pars_vertex,
        envmap_physical_pars_fragment: envmap_physical_pars_fragment,
        envmap_vertex: envmap_vertex,
        fog_vertex: fog_vertex,
        fog_pars_vertex: fog_pars_vertex,
        fog_fragment: fog_fragment,
        fog_pars_fragment: fog_pars_fragment,
        gradientmap_pars_fragment: gradientmap_pars_fragment,
        lightmap_fragment: lightmap_fragment,
        lightmap_pars_fragment: lightmap_pars_fragment,
        lights_lambert_vertex: lights_lambert_vertex,
        lights_pars_begin: lights_pars_begin,
        lights_toon_fragment: lights_toon_fragment,
        lights_toon_pars_fragment: lights_toon_pars_fragment,
        lights_phong_fragment: lights_phong_fragment,
        lights_phong_pars_fragment: lights_phong_pars_fragment,
        lights_physical_fragment: lights_physical_fragment,
        lights_physical_pars_fragment: lights_physical_pars_fragment,
        lights_fragment_begin: lights_fragment_begin,
        lights_fragment_maps: lights_fragment_maps,
        lights_fragment_end: lights_fragment_end,
        logdepthbuf_fragment: logdepthbuf_fragment,
        logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
        logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
        logdepthbuf_vertex: logdepthbuf_vertex,
        map_fragment: map_fragment,
        map_pars_fragment: map_pars_fragment,
        map_particle_fragment: map_particle_fragment,
        map_particle_pars_fragment: map_particle_pars_fragment,
        metalnessmap_fragment: metalnessmap_fragment,
        metalnessmap_pars_fragment: metalnessmap_pars_fragment,
        morphnormal_vertex: morphnormal_vertex,
        morphtarget_pars_vertex: morphtarget_pars_vertex,
        morphtarget_vertex: morphtarget_vertex,
        normal_fragment_begin: normal_fragment_begin,
        normal_fragment_maps: normal_fragment_maps,
        normalmap_pars_fragment: normalmap_pars_fragment,
        clearcoat_normal_fragment_begin: clearcoat_normal_fragment_begin,
        clearcoat_normal_fragment_maps: clearcoat_normal_fragment_maps,
        clearcoat_pars_fragment: clearcoat_pars_fragment,
        packing: packing,
        premultiplied_alpha_fragment: premultiplied_alpha_fragment,
        project_vertex: project_vertex,
        dithering_fragment: dithering_fragment,
        dithering_pars_fragment: dithering_pars_fragment,
        roughnessmap_fragment: roughnessmap_fragment,
        roughnessmap_pars_fragment: roughnessmap_pars_fragment,
        shadowmap_pars_fragment: shadowmap_pars_fragment,
        shadowmap_pars_vertex: shadowmap_pars_vertex,
        shadowmap_vertex: shadowmap_vertex,
        shadowmask_pars_fragment: shadowmask_pars_fragment,
        skinbase_vertex: skinbase_vertex,
        skinning_pars_vertex: skinning_pars_vertex,
        skinning_vertex: skinning_vertex,
        skinnormal_vertex: skinnormal_vertex,
        specularmap_fragment: specularmap_fragment,
        specularmap_pars_fragment: specularmap_pars_fragment,
        tonemapping_fragment: tonemapping_fragment,
        tonemapping_pars_fragment: tonemapping_pars_fragment,
        transmissionmap_fragment: transmissionmap_fragment,
        transmissionmap_pars_fragment: transmissionmap_pars_fragment,
        uv_pars_fragment: uv_pars_fragment,
        uv_pars_vertex: uv_pars_vertex,
        uv_vertex: uv_vertex,
        uv2_pars_fragment: uv2_pars_fragment,
        uv2_pars_vertex: uv2_pars_vertex,
        uv2_vertex: uv2_vertex,
        worldpos_vertex: worldpos_vertex,

        background_frag: background_frag,
        background_vert: background_vert,
        cube_frag: cube_frag,
        cube_vert: cube_vert,
        depth_frag: depth_frag,
        depth_vert: depth_vert,
        distanceRGBA_frag: distanceRGBA_frag,
        distanceRGBA_vert: distanceRGBA_vert,
        equirect_frag: equirect_frag,
        equirect_vert: equirect_vert,
        linedashed_frag: linedashed_frag,
        linedashed_vert: linedashed_vert,
        meshbasic_frag: meshbasic_frag,
        meshbasic_vert: meshbasic_vert,
        meshlambert_frag: meshlambert_frag,
        meshlambert_vert: meshlambert_vert,
        meshmatcap_frag: meshmatcap_frag,
        meshmatcap_vert: meshmatcap_vert,
        meshtoon_frag: meshtoon_frag,
        meshtoon_vert: meshtoon_vert,
        meshphong_frag: meshphong_frag,
        meshphong_vert: meshphong_vert,
        meshphysical_frag: meshphysical_frag,
        meshphysical_vert: meshphysical_vert,
        normal_frag: normal_frag,
        normal_vert: normal_vert,
        points_frag: points_frag,
        points_vert: points_vert,
        shadow_frag: shadow_frag,
        shadow_vert: shadow_vert,
        sprite_frag: sprite_frag,
        sprite_vert: sprite_vert
    };

    /**
     * Uniforms library for shared webgl shaders
     */

    const UniformsLib = {

        common: {

                diffuse: { value: new Color( 0xeeeeee ) },
                opacity: { value: 1.0 },

                map: { value: null },
                uvTransform: { value: new Matrix3() },
                uv2Transform: { value: new Matrix3() },

                alphaMap: { value: null },

        },

        specularmap: {

                specularMap: { value: null },

        },

        envmap: {

                envMap: { value: null },
                flipEnvMap: { value: - 1 },
                reflectivity: { value: 1.0 },
                refractionRatio: { value: 0.98 },
                maxMipLevel: { value: 0 }

        },

        aomap: {

                aoMap: { value: null },
                aoMapIntensity: { value: 1 }

        },

        lightmap: {

                lightMap: { value: null },
                lightMapIntensity: { value: 1 }

        },

        emissivemap: {

                emissiveMap: { value: null }

        },

        bumpmap: {

                bumpMap: { value: null },
                bumpScale: { value: 1 }

        },

        normalmap: {

                normalMap: { value: null },
                normalScale: { value: new Vector2( 1, 1 ) }

        },

        displacementmap: {

                displacementMap: { value: null },
                displacementScale: { value: 1 },
                displacementBias: { value: 0 }

        },

        roughnessmap: {

                roughnessMap: { value: null }

        },

        metalnessmap: {

                metalnessMap: { value: null }

        },

        gradientmap: {

                gradientMap: { value: null }

        },

        fog: {

                fogDensity: { value: 0.00025 },
                fogNear: { value: 1 },
                fogFar: { value: 2000 },
                fogColor: { value: new Color( 0xffffff ) }

        },

        lights: {

                ambientLightColor: { value: [] },

                lightProbe: { value: [] },

                directionalLights: { value: [], properties: {
                        direction: {},
                        color: {}
                } },

                directionalLightShadows: { value: [], properties: {
                        shadowBias: {},
                        shadowNormalBias: {},
                        shadowRadius: {},
                        shadowMapSize: {}
                } },

                directionalShadowMap: { value: [] },
                directionalShadowMatrix: { value: [] },

                spotLights: { value: [], properties: {
                        color: {},
                        position: {},
                        direction: {},
                        distance: {},
                        coneCos: {},
                        penumbraCos: {},
                        decay: {}
                } },

                spotLightShadows: { value: [], properties: {
                        shadowBias: {},
                        shadowNormalBias: {},
                        shadowRadius: {},
                        shadowMapSize: {}
                } },

                spotShadowMap: { value: [] },
                spotShadowMatrix: { value: [] },

                pointLights: { value: [], properties: {
                        color: {},
                        position: {},
                        decay: {},
                        distance: {}
                } },

                pointLightShadows: { value: [], properties: {
                        shadowBias: {},
                        shadowNormalBias: {},
                        shadowRadius: {},
                        shadowMapSize: {},
                        shadowCameraNear: {},
                        shadowCameraFar: {}
                } },

                pointShadowMap: { value: [] },
                pointShadowMatrix: { value: [] },

                hemisphereLights: { value: [], properties: {
                        direction: {},
                        skyColor: {},
                        groundColor: {}
                } },

                // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
                rectAreaLights: { value: [], properties: {
                        color: {},
                        position: {},
                        width: {},
                        height: {}
                } },

                ltc_1: { value: null },
                ltc_2: { value: null }

        },

        points: {

                diffuse: { value: new Color( 0xeeeeee ) },
                opacity: { value: 1.0 },
                size: { value: 1.0 },
                scale: { value: 1.0 },
                map: { value: null },
                alphaMap: { value: null },
                uvTransform: { value: new Matrix3() }

        },

        sprite: {

                diffuse: { value: new Color( 0xeeeeee ) },
                opacity: { value: 1.0 },
                center: { value: new Vector2( 0.5, 0.5 ) },
                rotation: { value: 0.0 },
                map: { value: null },
                alphaMap: { value: null },
                uvTransform: { value: new Matrix3() }

        }

    };

    const ShaderLib = {

        basic: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.specularmap,
                        UniformsLib.envmap,
                        UniformsLib.aomap,
                        UniformsLib.lightmap,
                        UniformsLib.fog
                ] ),

                vertexShader: ShaderChunk.meshbasic_vert,
                fragmentShader: ShaderChunk.meshbasic_frag

        },

        lambert: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.specularmap,
                        UniformsLib.envmap,
                        UniformsLib.aomap,
                        UniformsLib.lightmap,
                        UniformsLib.emissivemap,
                        UniformsLib.fog,
                        UniformsLib.lights,
                        {
                                emissive: { value: new Color( 0x000000 ) }
                        }
                ] ),

                vertexShader: ShaderChunk.meshlambert_vert,
                fragmentShader: ShaderChunk.meshlambert_frag

        },

        phong: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.specularmap,
                        UniformsLib.envmap,
                        UniformsLib.aomap,
                        UniformsLib.lightmap,
                        UniformsLib.emissivemap,
                        UniformsLib.bumpmap,
                        UniformsLib.normalmap,
                        UniformsLib.displacementmap,
                        UniformsLib.fog,
                        UniformsLib.lights,
                        {
                                emissive: { value: new Color( 0x000000 ) },
                                specular: { value: new Color( 0x111111 ) },
                                shininess: { value: 30 }
                        }
                ] ),

                vertexShader: ShaderChunk.meshphong_vert,
                fragmentShader: ShaderChunk.meshphong_frag

        },

        standard: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.envmap,
                        UniformsLib.aomap,
                        UniformsLib.lightmap,
                        UniformsLib.emissivemap,
                        UniformsLib.bumpmap,
                        UniformsLib.normalmap,
                        UniformsLib.displacementmap,
                        UniformsLib.roughnessmap,
                        UniformsLib.metalnessmap,
                        UniformsLib.fog,
                        UniformsLib.lights,
                        {
                                emissive: { value: new Color( 0x000000 ) },
                                roughness: { value: 1.0 },
                                metalness: { value: 0.0 },
                                envMapIntensity: { value: 1 } // temporary
                        }
                ] ),

                vertexShader: ShaderChunk.meshphysical_vert,
                fragmentShader: ShaderChunk.meshphysical_frag

        },

        toon: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.aomap,
                        UniformsLib.lightmap,
                        UniformsLib.emissivemap,
                        UniformsLib.bumpmap,
                        UniformsLib.normalmap,
                        UniformsLib.displacementmap,
                        UniformsLib.gradientmap,
                        UniformsLib.fog,
                        UniformsLib.lights,
                        {
                                emissive: { value: new Color( 0x000000 ) }
                        }
                ] ),

                vertexShader: ShaderChunk.meshtoon_vert,
                fragmentShader: ShaderChunk.meshtoon_frag

        },

        matcap: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.bumpmap,
                        UniformsLib.normalmap,
                        UniformsLib.displacementmap,
                        UniformsLib.fog,
                        {
                                matcap: { value: null }
                        }
                ] ),

                vertexShader: ShaderChunk.meshmatcap_vert,
                fragmentShader: ShaderChunk.meshmatcap_frag

        },

        points: {

                uniforms: mergeUniforms( [
                        UniformsLib.points,
                        UniformsLib.fog
                ] ),

                vertexShader: ShaderChunk.points_vert,
                fragmentShader: ShaderChunk.points_frag

        },

        dashed: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.fog,
                        {
                                scale: { value: 1 },
                                dashSize: { value: 1 },
                                totalSize: { value: 2 }
                        }
                ] ),

                vertexShader: ShaderChunk.linedashed_vert,
                fragmentShader: ShaderChunk.linedashed_frag

        },

        depth: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.displacementmap
                ] ),

                vertexShader: ShaderChunk.depth_vert,
                fragmentShader: ShaderChunk.depth_frag

        },

        normal: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.bumpmap,
                        UniformsLib.normalmap,
                        UniformsLib.displacementmap,
                        {
                                opacity: { value: 1.0 }
                        }
                ] ),

                vertexShader: ShaderChunk.normal_vert,
                fragmentShader: ShaderChunk.normal_frag

        },

        sprite: {

                uniforms: mergeUniforms( [
                        UniformsLib.sprite,
                        UniformsLib.fog
                ] ),

                vertexShader: ShaderChunk.sprite_vert,
                fragmentShader: ShaderChunk.sprite_frag

        },

        background: {

                uniforms: {
                        uvTransform: { value: new Matrix3() },
                        t2D: { value: null },
                },

                vertexShader: ShaderChunk.background_vert,
                fragmentShader: ShaderChunk.background_frag

        },
        /* -------------------------------------------------------------------------
        //      Cube map shader
         ------------------------------------------------------------------------- */

        cube: {

                uniforms: mergeUniforms( [
                        UniformsLib.envmap,
                        {
                                opacity: { value: 1.0 }
                        }
                ] ),

                vertexShader: ShaderChunk.cube_vert,
                fragmentShader: ShaderChunk.cube_frag

        },

        equirect: {

                uniforms: {
                        tEquirect: { value: null },
                },

                vertexShader: ShaderChunk.equirect_vert,
                fragmentShader: ShaderChunk.equirect_frag

        },

        distanceRGBA: {

                uniforms: mergeUniforms( [
                        UniformsLib.common,
                        UniformsLib.displacementmap,
                        {
                                referencePosition: { value: new Vector3() },
                                nearDistance: { value: 1 },
                                farDistance: { value: 1000 }
                        }
                ] ),

                vertexShader: ShaderChunk.distanceRGBA_vert,
                fragmentShader: ShaderChunk.distanceRGBA_frag

        },

        shadow: {

                uniforms: mergeUniforms( [
                        UniformsLib.lights,
                        UniformsLib.fog,
                        {
                                color: { value: new Color( 0x00000 ) },
                                opacity: { value: 1.0 }
                        },
                ] ),

                vertexShader: ShaderChunk.shadow_vert,
                fragmentShader: ShaderChunk.shadow_frag

        }

    };

    ShaderLib.physical = {

        uniforms: mergeUniforms( [
                ShaderLib.standard.uniforms,
                {
                        clearcoat: { value: 0 },
                        clearcoatMap: { value: null },
                        clearcoatRoughness: { value: 0 },
                        clearcoatRoughnessMap: { value: null },
                        clearcoatNormalScale: { value: new Vector2( 1, 1 ) },
                        clearcoatNormalMap: { value: null },
                        sheen: { value: new Color( 0x000000 ) },
                        transmission: { value: 0 },
                        transmissionMap: { value: null },
                }
        ] ),

        vertexShader: ShaderChunk.meshphysical_vert,
        fragmentShader: ShaderChunk.meshphysical_frag

    };

    function WebGLBackground( renderer, cubemaps, state, objects, premultipliedAlpha ) {

        const clearColor = new Color( 0x000000 );
        let clearAlpha = 0;

        let planeMesh;
        let boxMesh;

        let currentBackground = null;
        let currentBackgroundVersion = 0;
        let currentTonemapping = null;

        function render( renderList, scene, camera, forceClear ) {

                let background = scene.isScene === true ? scene.background : null;

                if ( background && background.isTexture ) {

                        background = cubemaps.get( background );

                }

                // Ignore background in AR
                // TODO: Reconsider this.

                const xr = renderer.xr;
                const session = xr.getSession && xr.getSession();

                if ( session && session.environmentBlendMode === 'additive' ) {

                        background = null;

                }

                if ( background === null ) {

                        setClear( clearColor, clearAlpha );

                } else if ( background && background.isColor ) {

                        setClear( background, 1 );
                        forceClear = true;

                }

                if ( renderer.autoClear || forceClear ) {

                        renderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );

                }

                if ( background && ( background.isCubeTexture || background.isWebGLCubeRenderTarget || background.mapping === CubeUVReflectionMapping ) ) {

                        if ( boxMesh === undefined ) {

                                boxMesh = new Mesh(
                                        new BoxGeometry( 1, 1, 1 ),
                                        new ShaderMaterial( {
                                                name: 'BackgroundCubeMaterial',
                                                uniforms: cloneUniforms( ShaderLib.cube.uniforms ),
                                                vertexShader: ShaderLib.cube.vertexShader,
                                                fragmentShader: ShaderLib.cube.fragmentShader,
                                                side: BackSide,
                                                depthTest: false,
                                                depthWrite: false,
                                                fog: false
                                        } )
                                );

                                boxMesh.geometry.deleteAttribute( 'normal' );
                                boxMesh.geometry.deleteAttribute( 'uv' );

                                boxMesh.onBeforeRender = function ( renderer, scene, camera ) {

                                        this.matrixWorld.copyPosition( camera.matrixWorld );

                                };

                                // enable code injection for non-built-in material
                                Object.defineProperty( boxMesh.material, 'envMap', {

                                        get: function () {

                                                return this.uniforms.envMap.value;

                                        }

                                } );

                                objects.update( boxMesh );

                        }

                        if ( background.isWebGLCubeRenderTarget ) {

                                // TODO Deprecate

                                background = background.texture;

                        }

                        boxMesh.material.uniforms.envMap.value = background;
                        boxMesh.material.uniforms.flipEnvMap.value = ( background.isCubeTexture && background._needsFlipEnvMap ) ? - 1 : 1;

                        if ( currentBackground !== background ||
                                currentBackgroundVersion !== background.version ||
                                currentTonemapping !== renderer.toneMapping ) {

                                boxMesh.material.needsUpdate = true;

                                currentBackground = background;
                                currentBackgroundVersion = background.version;
                                currentTonemapping = renderer.toneMapping;

                        }

                        // push to the pre-sorted opaque render list
                        renderList.unshift( boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null );

                } else if ( background && background.isTexture ) {

                        if ( planeMesh === undefined ) {

                                planeMesh = new Mesh(
                                        new PlaneGeometry( 2, 2 ),
                                        new ShaderMaterial( {
                                                name: 'BackgroundMaterial',
                                                uniforms: cloneUniforms( ShaderLib.background.uniforms ),
                                                vertexShader: ShaderLib.background.vertexShader,
                                                fragmentShader: ShaderLib.background.fragmentShader,
                                                side: FrontSide,
                                                depthTest: false,
                                                depthWrite: false,
                                                fog: false
                                        } )
                                );

                                planeMesh.geometry.deleteAttribute( 'normal' );

                                // enable code injection for non-built-in material
                                Object.defineProperty( planeMesh.material, 'map', {

                                        get: function () {

                                                return this.uniforms.t2D.value;

                                        }

                                } );

                                objects.update( planeMesh );

                        }

                        planeMesh.material.uniforms.t2D.value = background;

                        if ( background.matrixAutoUpdate === true ) {

                                background.updateMatrix();

                        }

                        planeMesh.material.uniforms.uvTransform.value.copy( background.matrix );

                        if ( currentBackground !== background ||
                                currentBackgroundVersion !== background.version ||
                                currentTonemapping !== renderer.toneMapping ) {

                                planeMesh.material.needsUpdate = true;

                                currentBackground = background;
                                currentBackgroundVersion = background.version;
                                currentTonemapping = renderer.toneMapping;

                        }


                        // push to the pre-sorted opaque render list
                        renderList.unshift( planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null );

                }

        }

        function setClear( color, alpha ) {

                state.buffers.color.setClear( color.r, color.g, color.b, alpha, premultipliedAlpha );

        }

        return {

                getClearColor: function () {

                        return clearColor;

                },
                setClearColor: function ( color, alpha = 1 ) {

                        clearColor.set( color );
                        clearAlpha = alpha;
                        setClear( clearColor, clearAlpha );

                },
                getClearAlpha: function () {

                        return clearAlpha;

                },
                setClearAlpha: function ( alpha ) {

                        clearAlpha = alpha;
                        setClear( clearColor, clearAlpha );

                },
                render: render

        };

    }

    function WebGLBindingStates( gl, extensions, attributes, capabilities ) {

        const maxVertexAttributes = gl.getParameter( 34921 );

        const extension = capabilities.isWebGL2 ? null : extensions.get( 'OES_vertex_array_object' );
        const vaoAvailable = capabilities.isWebGL2 || extension !== null;

        const bindingStates = {};

        const defaultState = createBindingState( null );
        let currentState = defaultState;

        function setup( object, material, program, geometry, index ) {

                let updateBuffers = false;

                if ( vaoAvailable ) {

                        const state = getBindingState( geometry, program, material );

                        if ( currentState !== state ) {

                                currentState = state;
                                bindVertexArrayObject( currentState.object );

                        }

                        updateBuffers = needsUpdate( geometry, index );

                        if ( updateBuffers ) saveCache( geometry, index );

                } else {

                        const wireframe = ( material.wireframe === true );

                        if ( currentState.geometry !== geometry.id ||
                                currentState.program !== program.id ||
                                currentState.wireframe !== wireframe ) {

                                currentState.geometry = geometry.id;
                                currentState.program = program.id;
                                currentState.wireframe = wireframe;

                                updateBuffers = true;

                        }

                }

                if ( object.isInstancedMesh === true ) {

                        updateBuffers = true;

                }

                if ( index !== null ) {

                        attributes.update( index, 34963 );

                }

                if ( updateBuffers ) {

                        setupVertexAttributes( object, material, program, geometry );

                        if ( index !== null ) {

                                gl.bindBuffer( 34963, attributes.get( index ).buffer );

                        }

                }

        }

        function createVertexArrayObject() {

                if ( capabilities.isWebGL2 ) return gl.createVertexArray();

                return extension.createVertexArrayOES();

        }

        function bindVertexArrayObject( vao ) {

                if ( capabilities.isWebGL2 ) return gl.bindVertexArray( vao );

                return extension.bindVertexArrayOES( vao );

        }

        function deleteVertexArrayObject( vao ) {

                if ( capabilities.isWebGL2 ) return gl.deleteVertexArray( vao );

                return extension.deleteVertexArrayOES( vao );

        }

        function getBindingState( geometry, program, material ) {

                const wireframe = ( material.wireframe === true );

                let programMap = bindingStates[ geometry.id ];

                if ( programMap === undefined ) {

                        programMap = {};
                        bindingStates[ geometry.id ] = programMap;

                }

                let stateMap = programMap[ program.id ];

                if ( stateMap === undefined ) {

                        stateMap = {};
                        programMap[ program.id ] = stateMap;

                }

                let state = stateMap[ wireframe ];

                if ( state === undefined ) {

                        state = createBindingState( createVertexArrayObject() );
                        stateMap[ wireframe ] = state;

                }

                return state;

        }

        function createBindingState( vao ) {

                const newAttributes = [];
                const enabledAttributes = [];
                const attributeDivisors = [];

                for ( let i = 0; i < maxVertexAttributes; i ++ ) {

                        newAttributes[ i ] = 0;
                        enabledAttributes[ i ] = 0;
                        attributeDivisors[ i ] = 0;

                }

                return {

                        // for backward compatibility on non-VAO support browser
                        geometry: null,
                        program: null,
                        wireframe: false,

                        newAttributes: newAttributes,
                        enabledAttributes: enabledAttributes,
                        attributeDivisors: attributeDivisors,
                        object: vao,
                        attributes: {},
                        index: null

                };

        }

        function needsUpdate( geometry, index ) {

                const cachedAttributes = currentState.attributes;
                const geometryAttributes = geometry.attributes;

                let attributesNum = 0;

                for ( const key in geometryAttributes ) {

                        const cachedAttribute = cachedAttributes[ key ];
                        const geometryAttribute = geometryAttributes[ key ];

                        if ( cachedAttribute === undefined ) return true;

                        if ( cachedAttribute.attribute !== geometryAttribute ) return true;

                        if ( cachedAttribute.data !== geometryAttribute.data ) return true;

                        attributesNum ++;

                }

                if ( currentState.attributesNum !== attributesNum ) return true;

                if ( currentState.index !== index ) return true;

                return false;

        }

        function saveCache( geometry, index ) {

                const cache = {};
                const attributes = geometry.attributes;
                let attributesNum = 0;

                for ( const key in attributes ) {

                        const attribute = attributes[ key ];

                        const data = {};
                        data.attribute = attribute;

                        if ( attribute.data ) {

                                data.data = attribute.data;

                        }

                        cache[ key ] = data;

                        attributesNum ++;

                }

                currentState.attributes = cache;
                currentState.attributesNum = attributesNum;

                currentState.index = index;

        }

        function initAttributes() {

                const newAttributes = currentState.newAttributes;

                for ( let i = 0, il = newAttributes.length; i < il; i ++ ) {

                        newAttributes[ i ] = 0;

                }

        }

        function enableAttribute( attribute ) {

                enableAttributeAndDivisor( attribute, 0 );

        }

        function enableAttributeAndDivisor( attribute, meshPerAttribute ) {

                const newAttributes = currentState.newAttributes;
                const enabledAttributes = currentState.enabledAttributes;
                const attributeDivisors = currentState.attributeDivisors;

                newAttributes[ attribute ] = 1;

                if ( enabledAttributes[ attribute ] === 0 ) {

                        gl.enableVertexAttribArray( attribute );
                        enabledAttributes[ attribute ] = 1;

                }

                if ( attributeDivisors[ attribute ] !== meshPerAttribute ) {

                        const extension = capabilities.isWebGL2 ? gl : extensions.get( 'ANGLE_instanced_arrays' );

                        extension[ capabilities.isWebGL2 ? 'vertexAttribDivisor' : 'vertexAttribDivisorANGLE' ]( attribute, meshPerAttribute );
                        attributeDivisors[ attribute ] = meshPerAttribute;

                }

        }

        function disableUnusedAttributes() {

                const newAttributes = currentState.newAttributes;
                const enabledAttributes = currentState.enabledAttributes;

                for ( let i = 0, il = enabledAttributes.length; i < il; i ++ ) {

                        if ( enabledAttributes[ i ] !== newAttributes[ i ] ) {

                                gl.disableVertexAttribArray( i );
                                enabledAttributes[ i ] = 0;

                        }

                }

        }

        function vertexAttribPointer( index, size, type, normalized, stride, offset ) {

                if ( capabilities.isWebGL2 === true && ( type === 5124 || type === 5125 ) ) {

                        gl.vertexAttribIPointer( index, size, type, stride, offset );

                } else {

                        gl.vertexAttribPointer( index, size, type, normalized, stride, offset );

                }

        }

        function setupVertexAttributes( object, material, program, geometry ) {

                if ( capabilities.isWebGL2 === false && ( object.isInstancedMesh || geometry.isInstancedBufferGeometry ) ) {

                        if ( extensions.get( 'ANGLE_instanced_arrays' ) === null ) return;

                }

                initAttributes();

                const geometryAttributes = geometry.attributes;

                const programAttributes = program.getAttributes();

                const materialDefaultAttributeValues = material.defaultAttributeValues;

                for ( const name in programAttributes ) {

                        const programAttribute = programAttributes[ name ];

                        if ( programAttribute >= 0 ) {

                                const geometryAttribute = geometryAttributes[ name ];

                                if ( geometryAttribute !== undefined ) {

                                        const normalized = geometryAttribute.normalized;
                                        const size = geometryAttribute.itemSize;

                                        const attribute = attributes.get( geometryAttribute );

                                        // TODO Attribute may not be available on context restore

                                        if ( attribute === undefined ) continue;

                                        const buffer = attribute.buffer;
                                        const type = attribute.type;
                                        const bytesPerElement = attribute.bytesPerElement;

                                        if ( geometryAttribute.isInterleavedBufferAttribute ) {

                                                const data = geometryAttribute.data;
                                                const stride = data.stride;
                                                const offset = geometryAttribute.offset;

                                                if ( data && data.isInstancedInterleavedBuffer ) {

                                                        enableAttributeAndDivisor( programAttribute, data.meshPerAttribute );

                                                        if ( geometry._maxInstanceCount === undefined ) {

                                                                geometry._maxInstanceCount = data.meshPerAttribute * data.count;

                                                        }

                                                } else {

                                                        enableAttribute( programAttribute );

                                                }

                                                gl.bindBuffer( 34962, buffer );
                                                vertexAttribPointer( programAttribute, size, type, normalized, stride * bytesPerElement, offset * bytesPerElement );

                                        } else {

                                                if ( geometryAttribute.isInstancedBufferAttribute ) {

                                                        enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute );

                                                        if ( geometry._maxInstanceCount === undefined ) {

                                                                geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;

                                                        }

                                                } else {

                                                        enableAttribute( programAttribute );

                                                }

                                                gl.bindBuffer( 34962, buffer );
                                                vertexAttribPointer( programAttribute, size, type, normalized, 0, 0 );

                                        }

                                } else if ( name === 'instanceMatrix' ) {

                                        const attribute = attributes.get( object.instanceMatrix );

                                        // TODO Attribute may not be available on context restore

                                        if ( attribute === undefined ) continue;

                                        const buffer = attribute.buffer;
                                        const type = attribute.type;

                                        enableAttributeAndDivisor( programAttribute + 0, 1 );
                                        enableAttributeAndDivisor( programAttribute + 1, 1 );
                                        enableAttributeAndDivisor( programAttribute + 2, 1 );
                                        enableAttributeAndDivisor( programAttribute + 3, 1 );

                                        gl.bindBuffer( 34962, buffer );

                                        gl.vertexAttribPointer( programAttribute + 0, 4, type, false, 64, 0 );
                                        gl.vertexAttribPointer( programAttribute + 1, 4, type, false, 64, 16 );
                                        gl.vertexAttribPointer( programAttribute + 2, 4, type, false, 64, 32 );
                                        gl.vertexAttribPointer( programAttribute + 3, 4, type, false, 64, 48 );

                                } else if ( name === 'instanceColor' ) {

                                        const attribute = attributes.get( object.instanceColor );

                                        // TODO Attribute may not be available on context restore

                                        if ( attribute === undefined ) continue;

                                        const buffer = attribute.buffer;
                                        const type = attribute.type;

                                        enableAttributeAndDivisor( programAttribute, 1 );

                                        gl.bindBuffer( 34962, buffer );

                                        gl.vertexAttribPointer( programAttribute, 3, type, false, 12, 0 );

                                } else if ( materialDefaultAttributeValues !== undefined ) {

                                        const value = materialDefaultAttributeValues[ name ];

                                        if ( value !== undefined ) {

                                                switch ( value.length ) {

                                                        case 2:
                                                                gl.vertexAttrib2fv( programAttribute, value );
                                                                break;

                                                        case 3:
                                                                gl.vertexAttrib3fv( programAttribute, value );
                                                                break;

                                                        case 4:
                                                                gl.vertexAttrib4fv( programAttribute, value );
                                                                break;

                                                        default:
                                                                gl.vertexAttrib1fv( programAttribute, value );

                                                }

                                        }

                                }

                        }

                }

                disableUnusedAttributes();

        }

        function dispose() {

                reset();

                for ( const geometryId in bindingStates ) {

                        const programMap = bindingStates[ geometryId ];

                        for ( const programId in programMap ) {

                                const stateMap = programMap[ programId ];

                                for ( const wireframe in stateMap ) {

                                        deleteVertexArrayObject( stateMap[ wireframe ].object );

                                        delete stateMap[ wireframe ];

                                }

                                delete programMap[ programId ];

                        }

                        delete bindingStates[ geometryId ];

                }

        }

        function releaseStatesOfGeometry( geometry ) {

                if ( bindingStates[ geometry.id ] === undefined ) return;

                const programMap = bindingStates[ geometry.id ];

                for ( const programId in programMap ) {

                        const stateMap = programMap[ programId ];

                        for ( const wireframe in stateMap ) {

                                deleteVertexArrayObject( stateMap[ wireframe ].object );

                                delete stateMap[ wireframe ];

                        }

                        delete programMap[ programId ];

                }

                delete bindingStates[ geometry.id ];

        }

        function releaseStatesOfProgram( program ) {

                for ( const geometryId in bindingStates ) {

                        const programMap = bindingStates[ geometryId ];

                        if ( programMap[ program.id ] === undefined ) continue;

                        const stateMap = programMap[ program.id ];

                        for ( const wireframe in stateMap ) {

                                deleteVertexArrayObject( stateMap[ wireframe ].object );

                                delete stateMap[ wireframe ];

                        }

                        delete programMap[ program.id ];

                }

        }

        function reset() {

                resetDefaultState();

                if ( currentState === defaultState ) return;

                currentState = defaultState;
                bindVertexArrayObject( currentState.object );

        }

        // for backward-compatilibity

        function resetDefaultState() {

                defaultState.geometry = null;
                defaultState.program = null;
                defaultState.wireframe = false;

        }

        return {

                setup: setup,
                reset: reset,
                resetDefaultState: resetDefaultState,
                dispose: dispose,
                releaseStatesOfGeometry: releaseStatesOfGeometry,
                releaseStatesOfProgram: releaseStatesOfProgram,

                initAttributes: initAttributes,
                enableAttribute: enableAttribute,
                disableUnusedAttributes: disableUnusedAttributes

        };

    }

    function WebGLBufferRenderer( gl, extensions, info, capabilities ) {

        const isWebGL2 = capabilities.isWebGL2;

        let mode;

        function setMode( value ) {

                mode = value;

        }

        function render( start, count ) {

                gl.drawArrays( mode, start, count );

                info.update( count, mode, 1 );

        }

        function renderInstances( start, count, primcount ) {

                if ( primcount === 0 ) return;

                let extension, methodName;

                if ( isWebGL2 ) {

                        extension = gl;
                        methodName = 'drawArraysInstanced';

                } else {

                        extension = extensions.get( 'ANGLE_instanced_arrays' );
                        methodName = 'drawArraysInstancedANGLE';

                        if ( extension === null ) {

                                console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
                                return;

                        }

                }

                extension[ methodName ]( mode, start, count, primcount );

                info.update( count, mode, primcount );

        }

        //

        this.setMode = setMode;
        this.render = render;
        this.renderInstances = renderInstances;

    }

    function WebGLCapabilities( gl, extensions, parameters ) {

        let maxAnisotropy;

        function getMaxAnisotropy() {

                if ( maxAnisotropy !== undefined ) return maxAnisotropy;

                const extension = extensions.get( 'EXT_texture_filter_anisotropic' );

                if ( extension !== null ) {

                        maxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );

                } else {

                        maxAnisotropy = 0;

                }

                return maxAnisotropy;

        }

        function getMaxPrecision( precision ) {

                if ( precision === 'highp' ) {

                        if ( gl.getShaderPrecisionFormat( 35633, 36338 ).precision > 0 &&
                                gl.getShaderPrecisionFormat( 35632, 36338 ).precision > 0 ) {

                                return 'highp';

                        }

                        precision = 'mediump';

                }

                if ( precision === 'mediump' ) {

                        if ( gl.getShaderPrecisionFormat( 35633, 36337 ).precision > 0 &&
                                gl.getShaderPrecisionFormat( 35632, 36337 ).precision > 0 ) {

                                return 'mediump';

                        }

                }

                return 'lowp';

        }

        /* eslint-disable no-undef */
        const isWebGL2 = ( typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext ) ||
                ( typeof WebGL2ComputeRenderingContext !== 'undefined' && gl instanceof WebGL2ComputeRenderingContext );
        /* eslint-enable no-undef */

        let precision = parameters.precision !== undefined ? parameters.precision : 'highp';
        const maxPrecision = getMaxPrecision( precision );

        if ( maxPrecision !== precision ) {

                console.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' );
                precision = maxPrecision;

        }

        const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;

        const maxTextures = gl.getParameter( 34930 );
        const maxVertexTextures = gl.getParameter( 35660 );
        const maxTextureSize = gl.getParameter( 3379 );
        const maxCubemapSize = gl.getParameter( 34076 );

        const maxAttributes = gl.getParameter( 34921 );
        const maxVertexUniforms = gl.getParameter( 36347 );
        const maxVaryings = gl.getParameter( 36348 );
        const maxFragmentUniforms = gl.getParameter( 36349 );

        const vertexTextures = maxVertexTextures > 0;
        const floatFragmentTextures = isWebGL2 || !! extensions.get( 'OES_texture_float' );
        const floatVertexTextures = vertexTextures && floatFragmentTextures;

        const maxSamples = isWebGL2 ? gl.getParameter( 36183 ) : 0;

        return {

                isWebGL2: isWebGL2,

                getMaxAnisotropy: getMaxAnisotropy,
                getMaxPrecision: getMaxPrecision,

                precision: precision,
                logarithmicDepthBuffer: logarithmicDepthBuffer,

                maxTextures: maxTextures,
                maxVertexTextures: maxVertexTextures,
                maxTextureSize: maxTextureSize,
                maxCubemapSize: maxCubemapSize,

                maxAttributes: maxAttributes,
                maxVertexUniforms: maxVertexUniforms,
                maxVaryings: maxVaryings,
                maxFragmentUniforms: maxFragmentUniforms,

                vertexTextures: vertexTextures,
                floatFragmentTextures: floatFragmentTextures,
                floatVertexTextures: floatVertexTextures,

                maxSamples: maxSamples

        };

    }

    function WebGLClipping( properties ) {

        const scope = this;

        let globalState = null,
                numGlobalPlanes = 0,
                localClippingEnabled = false,
                renderingShadows = false;

        const plane = new Plane(),
                viewNormalMatrix = new Matrix3(),

                uniform = { value: null, needsUpdate: false };

        this.uniform = uniform;
        this.numPlanes = 0;
        this.numIntersection = 0;

        this.init = function ( planes, enableLocalClipping, camera ) {

                const enabled =
                        planes.length !== 0 ||
                        enableLocalClipping ||
                        // enable state of previous frame - the clipping code has to
                        // run another frame in order to reset the state:
                        numGlobalPlanes !== 0 ||
                        localClippingEnabled;

                localClippingEnabled = enableLocalClipping;

                globalState = projectPlanes( planes, camera, 0 );
                numGlobalPlanes = planes.length;

                return enabled;

        };

        this.beginShadows = function () {

                renderingShadows = true;
                projectPlanes( null );

        };

        this.endShadows = function () {

                renderingShadows = false;
                resetGlobalState();

        };

        this.setState = function ( material, camera, useCache ) {

                const planes = material.clippingPlanes,
                        clipIntersection = material.clipIntersection,
                        clipShadows = material.clipShadows;

                const materialProperties = properties.get( material );

                if ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) {

                        // there's no local clipping

                        if ( renderingShadows ) {

                                // there's no global clipping

                                projectPlanes( null );

                        } else {

                                resetGlobalState();

                        }

                } else {

                        const nGlobal = renderingShadows ? 0 : numGlobalPlanes,
                                lGlobal = nGlobal * 4;

                        let dstArray = materialProperties.clippingState || null;

                        uniform.value = dstArray; // ensure unique state

                        dstArray = projectPlanes( planes, camera, lGlobal, useCache );

                        for ( let i = 0; i !== lGlobal; ++ i ) {

                                dstArray[ i ] = globalState[ i ];

                        }

                        materialProperties.clippingState = dstArray;
                        this.numIntersection = clipIntersection ? this.numPlanes : 0;
                        this.numPlanes += nGlobal;

                }


        };

        function resetGlobalState() {

                if ( uniform.value !== globalState ) {

                        uniform.value = globalState;
                        uniform.needsUpdate = numGlobalPlanes > 0;

                }

                scope.numPlanes = numGlobalPlanes;
                scope.numIntersection = 0;

        }

        function projectPlanes( planes, camera, dstOffset, skipTransform ) {

                const nPlanes = planes !== null ? planes.length : 0;
                let dstArray = null;

                if ( nPlanes !== 0 ) {

                        dstArray = uniform.value;

                        if ( skipTransform !== true || dstArray === null ) {

                                const flatSize = dstOffset + nPlanes * 4,
                                        viewMatrix = camera.matrixWorldInverse;

                                viewNormalMatrix.getNormalMatrix( viewMatrix );

                                if ( dstArray === null || dstArray.length < flatSize ) {

                                        dstArray = new Float32Array( flatSize );

                                }

                                for ( let i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {

                                        plane.copy( planes[ i ] ).applyMatrix4( viewMatrix, viewNormalMatrix );

                                        plane.normal.toArray( dstArray, i4 );
                                        dstArray[ i4 + 3 ] = plane.constant;

                                }

                        }

                        uniform.value = dstArray;
                        uniform.needsUpdate = true;

                }

                scope.numPlanes = nPlanes;
                scope.numIntersection = 0;

                return dstArray;

        }

    }

    function WebGLCubeMaps( renderer ) {

        let cubemaps = new WeakMap();

        function mapTextureMapping( texture, mapping ) {

                if ( mapping === EquirectangularReflectionMapping ) {

                        texture.mapping = CubeReflectionMapping;

                } else if ( mapping === EquirectangularRefractionMapping ) {

                        texture.mapping = CubeRefractionMapping;

                }

                return texture;

        }

        function get( texture ) {

                if ( texture && texture.isTexture ) {

                        const mapping = texture.mapping;

                        if ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping ) {

                                if ( cubemaps.has( texture ) ) {

                                        const cubemap = cubemaps.get( texture ).texture;
                                        return mapTextureMapping( cubemap, texture.mapping );

                                } else {

                                        const image = texture.image;

                                        if ( image && image.height > 0 ) {

                                                const currentRenderList = renderer.getRenderList();
                                                const currentRenderTarget = renderer.getRenderTarget();

                                                const renderTarget = new WebGLCubeRenderTarget( image.height / 2 );
                                                renderTarget.fromEquirectangularTexture( renderer, texture );
                                                cubemaps.set( texture, renderTarget );

                                                renderer.setRenderTarget( currentRenderTarget );
                                                renderer.setRenderList( currentRenderList );

                                                texture.addEventListener( 'dispose', onTextureDispose );

                                                return mapTextureMapping( renderTarget.texture, texture.mapping );

                                        } else {

                                                // image not yet ready. try the conversion next frame

                                                return null;

                                        }

                                }

                        }

                }

                return texture;

        }

        function onTextureDispose( event ) {

                const texture = event.target;

                texture.removeEventListener( 'dispose', onTextureDispose );

                const cubemap = cubemaps.get( texture );

                if ( cubemap !== undefined ) {

                        cubemaps.delete( texture );
                        cubemap.dispose();

                }

        }

        function dispose() {

                cubemaps = new WeakMap();

        }

        return {
                get: get,
                dispose: dispose
        };

    }

    function WebGLExtensions( gl ) {

        const extensions = {};

        function getExtension( name ) {

                if ( extensions[ name ] !== undefined ) {

                        return extensions[ name ];

                }

                let extension;

                switch ( name ) {

                        case 'WEBGL_depth_texture':
                                extension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );
                                break;

                        case 'EXT_texture_filter_anisotropic':
                                extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );
                                break;

                        case 'WEBGL_compressed_texture_s3tc':
                                extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );
                                break;

                        case 'WEBGL_compressed_texture_pvrtc':
                                extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );
                                break;

                        default:
                                extension = gl.getExtension( name );

                }

                extensions[ name ] = extension;

                return extension;

        }

        return {

                has: function ( name ) {

                        return getExtension( name ) !== null;

                },

                init: function ( capabilities ) {

                        if ( capabilities.isWebGL2 ) {

                                getExtension( 'EXT_color_buffer_float' );

                        } else {

                                getExtension( 'WEBGL_depth_texture' );
                                getExtension( 'OES_texture_float' );
                                getExtension( 'OES_texture_half_float' );
                                getExtension( 'OES_texture_half_float_linear' );
                                getExtension( 'OES_standard_derivatives' );
                                getExtension( 'OES_element_index_uint' );
                                getExtension( 'OES_vertex_array_object' );
                                getExtension( 'ANGLE_instanced_arrays' );

                        }

                        getExtension( 'OES_texture_float_linear' );
                        getExtension( 'EXT_color_buffer_half_float' );

                },

                get: function ( name ) {

                        const extension = getExtension( name );

                        if ( extension === null ) {

                                console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );

                        }

                        return extension;

                }

        };

    }

    function WebGLGeometries( gl, attributes, info, bindingStates ) {

        const geometries = {};
        const wireframeAttributes = new WeakMap();

        function onGeometryDispose( event ) {

                const geometry = event.target;

                if ( geometry.index !== null ) {

                        attributes.remove( geometry.index );

                }

                for ( const name in geometry.attributes ) {

                        attributes.remove( geometry.attributes[ name ] );

                }

                geometry.removeEventListener( 'dispose', onGeometryDispose );

                delete geometries[ geometry.id ];

                const attribute = wireframeAttributes.get( geometry );

                if ( attribute ) {

                        attributes.remove( attribute );
                        wireframeAttributes.delete( geometry );

                }

                bindingStates.releaseStatesOfGeometry( geometry );

                if ( geometry.isInstancedBufferGeometry === true ) {

                        delete geometry._maxInstanceCount;

                }

                //

                info.memory.geometries --;

        }

        function get( object, geometry ) {

                if ( geometries[ geometry.id ] === true ) return geometry;

                geometry.addEventListener( 'dispose', onGeometryDispose );

                geometries[ geometry.id ] = true;

                info.memory.geometries ++;

                return geometry;

        }

        function update( geometry ) {

                const geometryAttributes = geometry.attributes;

                // Updating index buffer in VAO now. See WebGLBindingStates.

                for ( const name in geometryAttributes ) {

                        attributes.update( geometryAttributes[ name ], 34962 );

                }

                // morph targets

                const morphAttributes = geometry.morphAttributes;

                for ( const name in morphAttributes ) {

                        const array = morphAttributes[ name ];

                        for ( let i = 0, l = array.length; i < l; i ++ ) {

                                attributes.update( array[ i ], 34962 );

                        }

                }

        }

        function updateWireframeAttribute( geometry ) {

                const indices = [];

                const geometryIndex = geometry.index;
                const geometryPosition = geometry.attributes.position;
                let version = 0;

                if ( geometryIndex !== null ) {

                        const array = geometryIndex.array;
                        version = geometryIndex.version;

                        for ( let i = 0, l = array.length; i < l; i += 3 ) {

                                const a = array[ i + 0 ];
                                const b = array[ i + 1 ];
                                const c = array[ i + 2 ];

                                indices.push( a, b, b, c, c, a );

                        }

                } else {

                        const array = geometryPosition.array;
                        version = geometryPosition.version;

                        for ( let i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {

                                const a = i + 0;
                                const b = i + 1;
                                const c = i + 2;

                                indices.push( a, b, b, c, c, a );

                        }

                }

                const attribute = new ( arrayMax( indices ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );
                attribute.version = version;

                // Updating index buffer in VAO now. See WebGLBindingStates

                //

                const previousAttribute = wireframeAttributes.get( geometry );

                if ( previousAttribute ) attributes.remove( previousAttribute );

                //

                wireframeAttributes.set( geometry, attribute );

        }

        function getWireframeAttribute( geometry ) {

                const currentAttribute = wireframeAttributes.get( geometry );

                if ( currentAttribute ) {

                        const geometryIndex = geometry.index;

                        if ( geometryIndex !== null ) {

                                // if the attribute is obsolete, create a new one

                                if ( currentAttribute.version < geometryIndex.version ) {

                                        updateWireframeAttribute( geometry );

                                }

                        }

                } else {

                        updateWireframeAttribute( geometry );

                }

                return wireframeAttributes.get( geometry );

        }

        return {

                get: get,
                update: update,

                getWireframeAttribute: getWireframeAttribute

        };

    }

    function WebGLIndexedBufferRenderer( gl, extensions, info, capabilities ) {

        const isWebGL2 = capabilities.isWebGL2;

        let mode;

        function setMode( value ) {

                mode = value;

        }

        let type, bytesPerElement;

        function setIndex( value ) {

                type = value.type;
                bytesPerElement = value.bytesPerElement;

        }

        function render( start, count ) {

                gl.drawElements( mode, count, type, start * bytesPerElement );

                info.update( count, mode, 1 );

        }

        function renderInstances( start, count, primcount ) {

                if ( primcount === 0 ) return;

                let extension, methodName;

                if ( isWebGL2 ) {

                        extension = gl;
                        methodName = 'drawElementsInstanced';

                } else {

                        extension = extensions.get( 'ANGLE_instanced_arrays' );
                        methodName = 'drawElementsInstancedANGLE';

                        if ( extension === null ) {

                                console.error( 'THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
                                return;

                        }

                }

                extension[ methodName ]( mode, count, type, start * bytesPerElement, primcount );

                info.update( count, mode, primcount );

        }

        //

        this.setMode = setMode;
        this.setIndex = setIndex;
        this.render = render;
        this.renderInstances = renderInstances;

    }

    function WebGLInfo( gl ) {

        const memory = {
                geometries: 0,
                textures: 0
        };

        const render = {
                frame: 0,
                calls: 0,
                triangles: 0,
                points: 0,
                lines: 0
        };

        function update( count, mode, instanceCount ) {

                render.calls ++;

                switch ( mode ) {

                        case 4:
                                render.triangles += instanceCount * ( count / 3 );
                                break;

                        case 1:
                                render.lines += instanceCount * ( count / 2 );
                                break;

                        case 3:
                                render.lines += instanceCount * ( count - 1 );
                                break;

                        case 2:
                                render.lines += instanceCount * count;
                                break;

                        case 0:
                                render.points += instanceCount * count;
                                break;

                        default:
                                console.error( 'THREE.WebGLInfo: Unknown draw mode:', mode );
                                break;

                }

        }

        function reset() {

                render.frame ++;
                render.calls = 0;
                render.triangles = 0;
                render.points = 0;
                render.lines = 0;

        }

        return {
                memory: memory,
                render: render,
                programs: null,
                autoReset: true,
                reset: reset,
                update: update
        };

    }

    function numericalSort( a, b ) {

        return a[ 0 ] - b[ 0 ];

    }

    function absNumericalSort( a, b ) {

        return Math.abs( b[ 1 ] ) - Math.abs( a[ 1 ] );

    }

    function WebGLMorphtargets( gl ) {

        const influencesList = {};
        const morphInfluences = new Float32Array( 8 );

        const workInfluences = [];

        for ( let i = 0; i < 8; i ++ ) {

                workInfluences[ i ] = [ i, 0 ];

        }

        function update( object, geometry, material, program ) {

                const objectInfluences = object.morphTargetInfluences;

                // When object doesn't have morph target influences defined, we treat it as a 0-length array
                // This is important to make sure we set up morphTargetBaseInfluence / morphTargetInfluences

                const length = objectInfluences === undefined ? 0 : objectInfluences.length;

                let influences = influencesList[ geometry.id ];

                if ( influences === undefined ) {

                        // initialise list

                        influences = [];

                        for ( let i = 0; i < length; i ++ ) {

                                influences[ i ] = [ i, 0 ];

                        }

                        influencesList[ geometry.id ] = influences;

                }

                // Collect influences

                for ( let i = 0; i < length; i ++ ) {

                        const influence = influences[ i ];

                        influence[ 0 ] = i;
                        influence[ 1 ] = objectInfluences[ i ];

                }

                influences.sort( absNumericalSort );

                for ( let i = 0; i < 8; i ++ ) {

                        if ( i < length && influences[ i ][ 1 ] ) {

                                workInfluences[ i ][ 0 ] = influences[ i ][ 0 ];
                                workInfluences[ i ][ 1 ] = influences[ i ][ 1 ];

                        } else {

                                workInfluences[ i ][ 0 ] = Number.MAX_SAFE_INTEGER;
                                workInfluences[ i ][ 1 ] = 0;

                        }

                }

                workInfluences.sort( numericalSort );

                const morphTargets = material.morphTargets && geometry.morphAttributes.position;
                const morphNormals = material.morphNormals && geometry.morphAttributes.normal;

                let morphInfluencesSum = 0;

                for ( let i = 0; i < 8; i ++ ) {

                        const influence = workInfluences[ i ];
                        const index = influence[ 0 ];
                        const value = influence[ 1 ];

                        if ( index !== Number.MAX_SAFE_INTEGER && value ) {

                                if ( morphTargets && geometry.getAttribute( 'morphTarget' + i ) !== morphTargets[ index ] ) {

                                        geometry.setAttribute( 'morphTarget' + i, morphTargets[ index ] );

                                }

                                if ( morphNormals && geometry.getAttribute( 'morphNormal' + i ) !== morphNormals[ index ] ) {

                                        geometry.setAttribute( 'morphNormal' + i, morphNormals[ index ] );

                                }

                                morphInfluences[ i ] = value;
                                morphInfluencesSum += value;

                        } else {

                                if ( morphTargets && geometry.hasAttribute( 'morphTarget' + i ) === true ) {

                                        geometry.deleteAttribute( 'morphTarget' + i );

                                }

                                if ( morphNormals && geometry.hasAttribute( 'morphNormal' + i ) === true ) {

                                        geometry.deleteAttribute( 'morphNormal' + i );

                                }

                                morphInfluences[ i ] = 0;

                        }

                }

                // GLSL shader uses formula baseinfluence * base + sum(target * influence)
                // This allows us to switch between absolute morphs and relative morphs without changing shader code
                // When baseinfluence = 1 - sum(influence), the above is equivalent to sum((target - base) * influence)
                const morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;

                program.getUniforms().setValue( gl, 'morphTargetBaseInfluence', morphBaseInfluence );
                program.getUniforms().setValue( gl, 'morphTargetInfluences', morphInfluences );

        }

        return {

                update: update

        };

    }

    function WebGLObjects( gl, geometries, attributes, info ) {

        let updateMap = new WeakMap();

        function update( object ) {

                const frame = info.render.frame;

                const geometry = object.geometry;
                const buffergeometry = geometries.get( object, geometry );

                // Update once per frame

                if ( updateMap.get( buffergeometry ) !== frame ) {

                        geometries.update( buffergeometry );

                        updateMap.set( buffergeometry, frame );

                }

                if ( object.isInstancedMesh ) {

                        if ( object.hasEventListener( 'dispose', onInstancedMeshDispose ) === false ) {

                                object.addEventListener( 'dispose', onInstancedMeshDispose );

                        }

                        attributes.update( object.instanceMatrix, 34962 );

                        if ( object.instanceColor !== null ) {

                                attributes.update( object.instanceColor, 34962 );

                        }

                }

                return buffergeometry;

        }

        function dispose() {

                updateMap = new WeakMap();

        }

        function onInstancedMeshDispose( event ) {

                const instancedMesh = event.target;

                instancedMesh.removeEventListener( 'dispose', onInstancedMeshDispose );

                attributes.remove( instancedMesh.instanceMatrix );

                if ( instancedMesh.instanceColor !== null ) attributes.remove( instancedMesh.instanceColor );

        }

        return {

                update: update,
                dispose: dispose

        };

    }

    function DataTexture2DArray( data = null, width = 1, height = 1, depth = 1 ) {

        Texture.call( this, null );

        this.image = { data, width, height, depth };

        this.magFilter = NearestFilter;
        this.minFilter = NearestFilter;

        this.wrapR = ClampToEdgeWrapping;

        this.generateMipmaps = false;
        this.flipY = false;

        this.needsUpdate = true;

    }

    DataTexture2DArray.prototype = Object.create( Texture.prototype );
    DataTexture2DArray.prototype.constructor = DataTexture2DArray;
    DataTexture2DArray.prototype.isDataTexture2DArray = true;

    function DataTexture3D( data = null, width = 1, height = 1, depth = 1 ) {

        // We're going to add .setXXX() methods for setting properties later.
        // Users can still set in DataTexture3D directly.
        //
        //      const texture = new THREE.DataTexture3D( data, width, height, depth );
        //      texture.anisotropy = 16;
        //
        // See #14839

        Texture.call( this, null );

        this.image = { data, width, height, depth };

        this.magFilter = NearestFilter;
        this.minFilter = NearestFilter;

        this.wrapR = ClampToEdgeWrapping;

        this.generateMipmaps = false;
        this.flipY = false;

        this.needsUpdate = true;


    }

    DataTexture3D.prototype = Object.create( Texture.prototype );
    DataTexture3D.prototype.constructor = DataTexture3D;
    DataTexture3D.prototype.isDataTexture3D = true;

    /**
     * Uniforms of a program.
     * Those form a tree structure with a special top-level container for the root,
     * which you get by calling 'new WebGLUniforms( gl, program )'.
     *
     *
     * Properties of inner nodes including the top-level container:
     *
     * .seq - array of nested uniforms
     * .map - nested uniforms by name
     *
     *
     * Methods of all nodes except the top-level container:
     *
     * .setValue( gl, value, [textures] )
     *
     *          uploads a uniform value(s)
     *          the 'textures' parameter is needed for sampler uniforms
     *
     *
     * Static methods of the top-level container (textures factorizations):
     *
     * .upload( gl, seq, values, textures )
     *
     *          sets uniforms in 'seq' to 'values[id].value'
     *
     * .seqWithValue( seq, values ) : filteredSeq
     *
     *          filters 'seq' entries with corresponding entry in values
     *
     *
     * Methods of the top-level container (textures factorizations):
     *
     * .setValue( gl, name, value, textures )
     *
     *          sets uniform with  name 'name' to 'value'
     *
     * .setOptional( gl, obj, prop )
     *
     *          like .set for an optional property of the object
     *
     */

    const emptyTexture = new Texture();
    const emptyTexture2dArray = new DataTexture2DArray();
    const emptyTexture3d = new DataTexture3D();
    const emptyCubeTexture = new CubeTexture();

    // --- Utilities ---

    // Array Caches (provide typed arrays for temporary by size)

    const arrayCacheF32 = [];
    const arrayCacheI32 = [];

    // Float32Array caches used for uploading Matrix uniforms

    const mat4array = new Float32Array( 16 );
    const mat3array = new Float32Array( 9 );
    const mat2array = new Float32Array( 4 );

    // Flattening for arrays of vectors and matrices

    function flatten( array, nBlocks, blockSize ) {

        const firstElem = array[ 0 ];

        if ( firstElem <= 0 || firstElem > 0 ) return array;
        // unoptimized: ! isNaN( firstElem )
        // see http://jacksondunstan.com/articles/983

        const n = nBlocks * blockSize;
        let r = arrayCacheF32[ n ];

        if ( r === undefined ) {

                r = new Float32Array( n );
                arrayCacheF32[ n ] = r;

        }

        if ( nBlocks !== 0 ) {

                firstElem.toArray( r, 0 );

                for ( let i = 1, offset = 0; i !== nBlocks; ++ i ) {

                        offset += blockSize;
                        array[ i ].toArray( r, offset );

                }

        }

        return r;

    }

    function arraysEqual( a, b ) {

        if ( a.length !== b.length ) return false;

        for ( let i = 0, l = a.length; i < l; i ++ ) {

                if ( a[ i ] !== b[ i ] ) return false;

        }

        return true;

    }

    function copyArray( a, b ) {

        for ( let i = 0, l = b.length; i < l; i ++ ) {

                a[ i ] = b[ i ];

        }

    }

    // Texture unit allocation

    function allocTexUnits( textures, n ) {

        let r = arrayCacheI32[ n ];

        if ( r === undefined ) {

                r = new Int32Array( n );
                arrayCacheI32[ n ] = r;

        }

        for ( let i = 0; i !== n; ++ i ) {

                r[ i ] = textures.allocateTextureUnit();

        }

        return r;

    }

    // --- Setters ---

    // Note: Defining these methods externally, because they come in a bunch
    // and this way their names minify.

    // Single scalar

    function setValueV1f( gl, v ) {

        const cache = this.cache;

        if ( cache[ 0 ] === v ) return;

        gl.uniform1f( this.addr, v );

        cache[ 0 ] = v;

    }

    // Single float vector (from flat array or THREE.VectorN)

    function setValueV2f( gl, v ) {

        const cache = this.cache;

        if ( v.x !== undefined ) {

                if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {

                        gl.uniform2f( this.addr, v.x, v.y );

                        cache[ 0 ] = v.x;
                        cache[ 1 ] = v.y;

                }

        } else {

                if ( arraysEqual( cache, v ) ) return;

                gl.uniform2fv( this.addr, v );

                copyArray( cache, v );

        }

    }

    function setValueV3f( gl, v ) {

        const cache = this.cache;

        if ( v.x !== undefined ) {

                if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {

                        gl.uniform3f( this.addr, v.x, v.y, v.z );

                        cache[ 0 ] = v.x;
                        cache[ 1 ] = v.y;
                        cache[ 2 ] = v.z;

                }

        } else if ( v.r !== undefined ) {

                if ( cache[ 0 ] !== v.r || cache[ 1 ] !== v.g || cache[ 2 ] !== v.b ) {

                        gl.uniform3f( this.addr, v.r, v.g, v.b );

                        cache[ 0 ] = v.r;
                        cache[ 1 ] = v.g;
                        cache[ 2 ] = v.b;

                }

        } else {

                if ( arraysEqual( cache, v ) ) return;

                gl.uniform3fv( this.addr, v );

                copyArray( cache, v );

        }

    }

    function setValueV4f( gl, v ) {

        const cache = this.cache;

        if ( v.x !== undefined ) {

                if ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {

                        gl.uniform4f( this.addr, v.x, v.y, v.z, v.w );

                        cache[ 0 ] = v.x;
                        cache[ 1 ] = v.y;
                        cache[ 2 ] = v.z;
                        cache[ 3 ] = v.w;

                }

        } else {

                if ( arraysEqual( cache, v ) ) return;

                gl.uniform4fv( this.addr, v );

                copyArray( cache, v );

        }

    }

    // Single matrix (from flat array or MatrixN)

    function setValueM2( gl, v ) {

        const cache = this.cache;
        const elements = v.elements;

        if ( elements === undefined ) {

                if ( arraysEqual( cache, v ) ) return;

                gl.uniformMatrix2fv( this.addr, false, v );

                copyArray( cache, v );

        } else {

                if ( arraysEqual( cache, elements ) ) return;

                mat2array.set( elements );

                gl.uniformMatrix2fv( this.addr, false, mat2array );

                copyArray( cache, elements );

        }

    }

    function setValueM3( gl, v ) {

        const cache = this.cache;
        const elements = v.elements;

        if ( elements === undefined ) {

                if ( arraysEqual( cache, v ) ) return;

                gl.uniformMatrix3fv( this.addr, false, v );

                copyArray( cache, v );

        } else {

                if ( arraysEqual( cache, elements ) ) return;

                mat3array.set( elements );

                gl.uniformMatrix3fv( this.addr, false, mat3array );

                copyArray( cache, elements );

        }

    }

    function setValueM4( gl, v ) {

        const cache = this.cache;
        const elements = v.elements;

        if ( elements === undefined ) {

                if ( arraysEqual( cache, v ) ) return;

                gl.uniformMatrix4fv( this.addr, false, v );

                copyArray( cache, v );

        } else {

                if ( arraysEqual( cache, elements ) ) return;

                mat4array.set( elements );

                gl.uniformMatrix4fv( this.addr, false, mat4array );

                copyArray( cache, elements );

        }

    }

    // Single texture (2D / Cube)

    function setValueT1( gl, v, textures ) {

        const cache = this.cache;
        const unit = textures.allocateTextureUnit();

        if ( cache[ 0 ] !== unit ) {

                gl.uniform1i( this.addr, unit );
                cache[ 0 ] = unit;

        }

        textures.safeSetTexture2D( v || emptyTexture, unit );

    }

    function setValueT2DArray1( gl, v, textures ) {

        const cache = this.cache;
        const unit = textures.allocateTextureUnit();

        if ( cache[ 0 ] !== unit ) {

                gl.uniform1i( this.addr, unit );
                cache[ 0 ] = unit;

        }

        textures.setTexture2DArray( v || emptyTexture2dArray, unit );

    }

    function setValueT3D1( gl, v, textures ) {

        const cache = this.cache;
        const unit = textures.allocateTextureUnit();

        if ( cache[ 0 ] !== unit ) {

                gl.uniform1i( this.addr, unit );
                cache[ 0 ] = unit;

        }

        textures.setTexture3D( v || emptyTexture3d, unit );

    }

    function setValueT6( gl, v, textures ) {

        const cache = this.cache;
        const unit = textures.allocateTextureUnit();

        if ( cache[ 0 ] !== unit ) {

                gl.uniform1i( this.addr, unit );
                cache[ 0 ] = unit;

        }

        textures.safeSetTextureCube( v || emptyCubeTexture, unit );

    }

    // Integer / Boolean vectors or arrays thereof (always flat arrays)

    function setValueV1i( gl, v ) {

        const cache = this.cache;

        if ( cache[ 0 ] === v ) return;

        gl.uniform1i( this.addr, v );

        cache[ 0 ] = v;

    }

    function setValueV2i( gl, v ) {

        const cache = this.cache;

        if ( arraysEqual( cache, v ) ) return;

        gl.uniform2iv( this.addr, v );

        copyArray( cache, v );

    }

    function setValueV3i( gl, v ) {

        const cache = this.cache;

        if ( arraysEqual( cache, v ) ) return;

        gl.uniform3iv( this.addr, v );

        copyArray( cache, v );

    }

    function setValueV4i( gl, v ) {

        const cache = this.cache;

        if ( arraysEqual( cache, v ) ) return;

        gl.uniform4iv( this.addr, v );

        copyArray( cache, v );

    }

    // uint

    function setValueV1ui( gl, v ) {

        const cache = this.cache;

        if ( cache[ 0 ] === v ) return;

        gl.uniform1ui( this.addr, v );

        cache[ 0 ] = v;

    }

    // Helper to pick the right setter for the singular case

    function getSingularSetter( type ) {

        switch ( type ) {

                case 0x1406: return setValueV1f; // FLOAT
                case 0x8b50: return setValueV2f; // _VEC2
                case 0x8b51: return setValueV3f; // _VEC3
                case 0x8b52: return setValueV4f; // _VEC4

                case 0x8b5a: return setValueM2; // _MAT2
                case 0x8b5b: return setValueM3; // _MAT3
                case 0x8b5c: return setValueM4; // _MAT4

                case 0x1404: case 0x8b56: return setValueV1i; // INT, BOOL
                case 0x8b53: case 0x8b57: return setValueV2i; // _VEC2
                case 0x8b54: case 0x8b58: return setValueV3i; // _VEC3
                case 0x8b55: case 0x8b59: return setValueV4i; // _VEC4

                case 0x1405: return setValueV1ui; // UINT

                case 0x8b5e: // SAMPLER_2D
                case 0x8d66: // SAMPLER_EXTERNAL_OES
                case 0x8dca: // INT_SAMPLER_2D
                case 0x8dd2: // UNSIGNED_INT_SAMPLER_2D
                case 0x8b62: // SAMPLER_2D_SHADOW
                        return setValueT1;

                case 0x8b5f: // SAMPLER_3D
                case 0x8dcb: // INT_SAMPLER_3D
                case 0x8dd3: // UNSIGNED_INT_SAMPLER_3D
                        return setValueT3D1;

                case 0x8b60: // SAMPLER_CUBE
                case 0x8dcc: // INT_SAMPLER_CUBE
                case 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE
                case 0x8dc5: // SAMPLER_CUBE_SHADOW
                        return setValueT6;

                case 0x8dc1: // SAMPLER_2D_ARRAY
                case 0x8dcf: // INT_SAMPLER_2D_ARRAY
                case 0x8dd7: // UNSIGNED_INT_SAMPLER_2D_ARRAY
                case 0x8dc4: // SAMPLER_2D_ARRAY_SHADOW
                        return setValueT2DArray1;

        }

    }

    // Array of scalars
    function setValueV1fArray( gl, v ) {

        gl.uniform1fv( this.addr, v );

    }

    // Integer / Boolean vectors or arrays thereof (always flat arrays)
    function setValueV1iArray( gl, v ) {

        gl.uniform1iv( this.addr, v );

    }

    function setValueV2iArray( gl, v ) {

        gl.uniform2iv( this.addr, v );

    }

    function setValueV3iArray( gl, v ) {

        gl.uniform3iv( this.addr, v );

    }

    function setValueV4iArray( gl, v ) {

        gl.uniform4iv( this.addr, v );

    }


    // Array of vectors (flat or from THREE classes)

    function setValueV2fArray( gl, v ) {

        const data = flatten( v, this.size, 2 );

        gl.uniform2fv( this.addr, data );

    }

    function setValueV3fArray( gl, v ) {

        const data = flatten( v, this.size, 3 );

        gl.uniform3fv( this.addr, data );

    }

    function setValueV4fArray( gl, v ) {

        const data = flatten( v, this.size, 4 );

        gl.uniform4fv( this.addr, data );

    }

    // Array of matrices (flat or from THREE clases)

    function setValueM2Array( gl, v ) {

        const data = flatten( v, this.size, 4 );

        gl.uniformMatrix2fv( this.addr, false, data );

    }

    function setValueM3Array( gl, v ) {

        const data = flatten( v, this.size, 9 );

        gl.uniformMatrix3fv( this.addr, false, data );

    }

    function setValueM4Array( gl, v ) {

        const data = flatten( v, this.size, 16 );

        gl.uniformMatrix4fv( this.addr, false, data );

    }

    // Array of textures (2D / Cube)

    function setValueT1Array( gl, v, textures ) {

        const n = v.length;

        const units = allocTexUnits( textures, n );

        gl.uniform1iv( this.addr, units );

        for ( let i = 0; i !== n; ++ i ) {

                textures.safeSetTexture2D( v[ i ] || emptyTexture, units[ i ] );

        }

    }

    function setValueT6Array( gl, v, textures ) {

        const n = v.length;

        const units = allocTexUnits( textures, n );

        gl.uniform1iv( this.addr, units );

        for ( let i = 0; i !== n; ++ i ) {

                textures.safeSetTextureCube( v[ i ] || emptyCubeTexture, units[ i ] );

        }

    }

    // Helper to pick the right setter for a pure (bottom-level) array

    function getPureArraySetter( type ) {

        switch ( type ) {

                case 0x1406: return setValueV1fArray; // FLOAT
                case 0x8b50: return setValueV2fArray; // _VEC2
                case 0x8b51: return setValueV3fArray; // _VEC3
                case 0x8b52: return setValueV4fArray; // _VEC4

                case 0x8b5a: return setValueM2Array; // _MAT2
                case 0x8b5b: return setValueM3Array; // _MAT3
                case 0x8b5c: return setValueM4Array; // _MAT4

                case 0x1404: case 0x8b56: return setValueV1iArray; // INT, BOOL
                case 0x8b53: case 0x8b57: return setValueV2iArray; // _VEC2
                case 0x8b54: case 0x8b58: return setValueV3iArray; // _VEC3
                case 0x8b55: case 0x8b59: return setValueV4iArray; // _VEC4

                case 0x8b5e: // SAMPLER_2D
                case 0x8d66: // SAMPLER_EXTERNAL_OES
                case 0x8dca: // INT_SAMPLER_2D
                case 0x8dd2: // UNSIGNED_INT_SAMPLER_2D
                case 0x8b62: // SAMPLER_2D_SHADOW
                        return setValueT1Array;

                case 0x8b60: // SAMPLER_CUBE
                case 0x8dcc: // INT_SAMPLER_CUBE
                case 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE
                case 0x8dc5: // SAMPLER_CUBE_SHADOW
                        return setValueT6Array;

        }

    }

    // --- Uniform Classes ---

    function SingleUniform( id, activeInfo, addr ) {

        this.id = id;
        this.addr = addr;
        this.cache = [];
        this.setValue = getSingularSetter( activeInfo.type );

        // this.path = activeInfo.name; // DEBUG

    }

    function PureArrayUniform( id, activeInfo, addr ) {

        this.id = id;
        this.addr = addr;
        this.cache = [];
        this.size = activeInfo.size;
        this.setValue = getPureArraySetter( activeInfo.type );

        // this.path = activeInfo.name; // DEBUG

    }

    PureArrayUniform.prototype.updateCache = function ( data ) {

        const cache = this.cache;

        if ( data instanceof Float32Array && cache.length !== data.length ) {

                this.cache = new Float32Array( data.length );

        }

        copyArray( cache, data );

    };

    function StructuredUniform( id ) {

        this.id = id;

        this.seq = [];
        this.map = {};

    }

    StructuredUniform.prototype.setValue = function ( gl, value, textures ) {

        const seq = this.seq;

        for ( let i = 0, n = seq.length; i !== n; ++ i ) {

                const u = seq[ i ];
                u.setValue( gl, value[ u.id ], textures );

        }

    };

    // --- Top-level ---

    // Parser - builds up the property tree from the path strings

    const RePathPart = /(\w+)(\])?(\[|\.)?/g;

    // extracts
    //  - the identifier (member name or array index)
    //  - followed by an optional right bracket (found when array index)
    //  - followed by an optional left bracket or dot (type of subscript)
    //
    // Note: These portions can be read in a non-overlapping fashion and
    // allow straightforward parsing of the hierarchy that WebGL encodes
    // in the uniform names.

    function addUniform( container, uniformObject ) {

        container.seq.push( uniformObject );
        container.map[ uniformObject.id ] = uniformObject;

    }

    function parseUniform( activeInfo, addr, container ) {

        const path = activeInfo.name,
                pathLength = path.length;

        // reset RegExp object, because of the early exit of a previous run
        RePathPart.lastIndex = 0;

        while ( true ) {

                const match = RePathPart.exec( path ),
                        matchEnd = RePathPart.lastIndex;

                let id = match[ 1 ];
                const idIsIndex = match[ 2 ] === ']',
                        subscript = match[ 3 ];

                if ( idIsIndex ) id = id | 0; // convert to integer

                if ( subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength ) {

                        // bare name or "pure" bottom-level array "[0]" suffix

                        addUniform( container, subscript === undefined ?
                                new SingleUniform( id, activeInfo, addr ) :
                                new PureArrayUniform( id, activeInfo, addr ) );

                        break;

                } else {

                        // step into inner node / create it in case it doesn't exist

                        const map = container.map;
                        let next = map[ id ];

                        if ( next === undefined ) {

                                next = new StructuredUniform( id );
                                addUniform( container, next );

                        }

                        container = next;

                }

        }

    }

    // Root Container

    function WebGLUniforms( gl, program ) {

        this.seq = [];
        this.map = {};

        const n = gl.getProgramParameter( program, 35718 );

        for ( let i = 0; i < n; ++ i ) {

                const info = gl.getActiveUniform( program, i ),
                        addr = gl.getUniformLocation( program, info.name );

                parseUniform( info, addr, this );

        }

    }

    WebGLUniforms.prototype.setValue = function ( gl, name, value, textures ) {

        const u = this.map[ name ];

        if ( u !== undefined ) u.setValue( gl, value, textures );

    };

    WebGLUniforms.prototype.setOptional = function ( gl, object, name ) {

        const v = object[ name ];

        if ( v !== undefined ) this.setValue( gl, name, v );

    };


    // Static interface

    WebGLUniforms.upload = function ( gl, seq, values, textures ) {

        for ( let i = 0, n = seq.length; i !== n; ++ i ) {

                const u = seq[ i ],
                        v = values[ u.id ];

                if ( v.needsUpdate !== false ) {

                        // note: always updating when .needsUpdate is undefined
                        u.setValue( gl, v.value, textures );

                }

        }

    };

    WebGLUniforms.seqWithValue = function ( seq, values ) {

        const r = [];

        for ( let i = 0, n = seq.length; i !== n; ++ i ) {

                const u = seq[ i ];
                if ( u.id in values ) r.push( u );

        }

        return r;

    };

    function WebGLShader( gl, type, string ) {

        const shader = gl.createShader( type );

        gl.shaderSource( shader, string );
        gl.compileShader( shader );

        return shader;

    }

    let programIdCount = 0;

    function addLineNumbers( string ) {

        const lines = string.split( '\n' );

        for ( let i = 0; i < lines.length; i ++ ) {

                lines[ i ] = ( i + 1 ) + ': ' + lines[ i ];

        }

        return lines.join( '\n' );

    }

    function getEncodingComponents( encoding ) {

        switch ( encoding ) {

                case LinearEncoding:
                        return [ 'Linear', '( value )' ];
                case sRGBEncoding:
                        return [ 'sRGB', '( value )' ];
                case RGBEEncoding:
                        return [ 'RGBE', '( value )' ];
                case RGBM7Encoding:
                        return [ 'RGBM', '( value, 7.0 )' ];
                case RGBM16Encoding:
                        return [ 'RGBM', '( value, 16.0 )' ];
                case RGBDEncoding:
                        return [ 'RGBD', '( value, 256.0 )' ];
                case GammaEncoding:
                        return [ 'Gamma', '( value, float( GAMMA_FACTOR ) )' ];
                case LogLuvEncoding:
                        return [ 'LogLuv', '( value )' ];
                default:
                        console.warn( 'THREE.WebGLProgram: Unsupported encoding:', encoding );
                        return [ 'Linear', '( value )' ];

        }

    }

    function getShaderErrors( gl, shader, type ) {

        const status = gl.getShaderParameter( shader, 35713 );
        const log = gl.getShaderInfoLog( shader ).trim();

        if ( status && log === '' ) return '';

        // --enable-privileged-webgl-extension
        // console.log( '**' + type + '**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );

        const source = gl.getShaderSource( shader );

        return 'THREE.WebGLShader: gl.getShaderInfoLog() ' + type + '\n' + log + addLineNumbers( source );

    }

    function getTexelDecodingFunction( functionName, encoding ) {

        const components = getEncodingComponents( encoding );
        return 'vec4 ' + functionName + '( vec4 value ) { return ' + components[ 0 ] + 'ToLinear' + components[ 1 ] + '; }';

    }

    function getTexelEncodingFunction( functionName, encoding ) {

        const components = getEncodingComponents( encoding );
        return 'vec4 ' + functionName + '( vec4 value ) { return LinearTo' + components[ 0 ] + components[ 1 ] + '; }';

    }

    function getToneMappingFunction( functionName, toneMapping ) {

        let toneMappingName;

        switch ( toneMapping ) {

                case LinearToneMapping:
                        toneMappingName = 'Linear';
                        break;

                case ReinhardToneMapping:
                        toneMappingName = 'Reinhard';
                        break;

                case CineonToneMapping:
                        toneMappingName = 'OptimizedCineon';
                        break;

                case ACESFilmicToneMapping:
                        toneMappingName = 'ACESFilmic';
                        break;

                case CustomToneMapping:
                        toneMappingName = 'Custom';
                        break;

                default:
                        console.warn( 'THREE.WebGLProgram: Unsupported toneMapping:', toneMapping );
                        toneMappingName = 'Linear';

        }

        return 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';

    }

    function generateExtensions( parameters ) {

        const chunks = [
                ( parameters.extensionDerivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.tangentSpaceNormalMap || parameters.clearcoatNormalMap || parameters.flatShading || parameters.shaderID === 'physical' ) ? '#extension GL_OES_standard_derivatives : enable' : '',
                ( parameters.extensionFragDepth || parameters.logarithmicDepthBuffer ) && parameters.rendererExtensionFragDepth ? '#extension GL_EXT_frag_depth : enable' : '',
                ( parameters.extensionDrawBuffers && parameters.rendererExtensionDrawBuffers ) ? '#extension GL_EXT_draw_buffers : require' : '',
                ( parameters.extensionShaderTextureLOD || parameters.envMap ) && parameters.rendererExtensionShaderTextureLod ? '#extension GL_EXT_shader_texture_lod : enable' : ''
        ];

        return chunks.filter( filterEmptyLine ).join( '\n' );

    }

    function generateDefines( defines ) {

        const chunks = [];

        for ( const name in defines ) {

                const value = defines[ name ];

                if ( value === false ) continue;

                chunks.push( '#define ' + name + ' ' + value );

        }

        return chunks.join( '\n' );

    }

    function fetchAttributeLocations( gl, program ) {

        const attributes = {};

        const n = gl.getProgramParameter( program, 35721 );

        for ( let i = 0; i < n; i ++ ) {

                const info = gl.getActiveAttrib( program, i );
                const name = info.name;

                // console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );

                attributes[ name ] = gl.getAttribLocation( program, name );

        }

        return attributes;

    }

    function filterEmptyLine( string ) {

        return string !== '';

    }

    function replaceLightNums( string, parameters ) {

        return string
                .replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )
                .replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )
                .replace( /NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights )
                .replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )
                .replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights )
                .replace( /NUM_DIR_LIGHT_SHADOWS/g, parameters.numDirLightShadows )
                .replace( /NUM_SPOT_LIGHT_SHADOWS/g, parameters.numSpotLightShadows )
                .replace( /NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows );

    }

    function replaceClippingPlaneNums( string, parameters ) {

        return string
                .replace( /NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes )
                .replace( /UNION_CLIPPING_PLANES/g, ( parameters.numClippingPlanes - parameters.numClipIntersection ) );

    }

    // Resolve Includes

    const includePattern = /^[ \t]*#include +<([\w\d./]+)>/gm;

    function resolveIncludes( string ) {

        return string.replace( includePattern, includeReplacer );

    }

    function includeReplacer( match, include ) {

        const string = ShaderChunk[ include ];

        if ( string === undefined ) {

                throw new Error( 'Can not resolve #include <' + include + '>' );

        }

        return resolveIncludes( string );

    }

    // Unroll Loops

    const deprecatedUnrollLoopPattern = /#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g;
    const unrollLoopPattern = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;

    function unrollLoops( string ) {

        return string
                .replace( unrollLoopPattern, loopReplacer )
                .replace( deprecatedUnrollLoopPattern, deprecatedLoopReplacer );

    }

    function deprecatedLoopReplacer( match, start, end, snippet ) {

        console.warn( 'WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead.' );
        return loopReplacer( match, start, end, snippet );

    }

    function loopReplacer( match, start, end, snippet ) {

        let string = '';

        for ( let i = parseInt( start ); i < parseInt( end ); i ++ ) {

                string += snippet
                        .replace( /\[\s*i\s*\]/g, '[ ' + i + ' ]' )
                        .replace( /UNROLLED_LOOP_INDEX/g, i );

        }

        return string;

    }

    //

    function generatePrecision( parameters ) {

        let precisionstring = 'precision ' + parameters.precision + ' float;\nprecision ' + parameters.precision + ' int;';

        if ( parameters.precision === 'highp' ) {

                precisionstring += '\n#define HIGH_PRECISION';

        } else if ( parameters.precision === 'mediump' ) {

                precisionstring += '\n#define MEDIUM_PRECISION';

        } else if ( parameters.precision === 'lowp' ) {

                precisionstring += '\n#define LOW_PRECISION';

        }

        return precisionstring;

    }

    function generateShadowMapTypeDefine( parameters ) {

        let shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';

        if ( parameters.shadowMapType === PCFShadowMap ) {

                shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';

        } else if ( parameters.shadowMapType === PCFSoftShadowMap ) {

                shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';

        } else if ( parameters.shadowMapType === VSMShadowMap ) {

                shadowMapTypeDefine = 'SHADOWMAP_TYPE_VSM';

        }

        return shadowMapTypeDefine;

    }

    function generateEnvMapTypeDefine( parameters ) {

        let envMapTypeDefine = 'ENVMAP_TYPE_CUBE';

        if ( parameters.envMap ) {

                switch ( parameters.envMapMode ) {

                        case CubeReflectionMapping:
                        case CubeRefractionMapping:
                                envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
                                break;

                        case CubeUVReflectionMapping:
                        case CubeUVRefractionMapping:
                                envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
                                break;

                }

        }

        return envMapTypeDefine;

    }

    function generateEnvMapModeDefine( parameters ) {

        let envMapModeDefine = 'ENVMAP_MODE_REFLECTION';

        if ( parameters.envMap ) {

                switch ( parameters.envMapMode ) {

                        case CubeRefractionMapping:
                        case CubeUVRefractionMapping:

                                envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
                                break;

                }

        }

        return envMapModeDefine;

    }

    function generateEnvMapBlendingDefine( parameters ) {

        let envMapBlendingDefine = 'ENVMAP_BLENDING_NONE';

        if ( parameters.envMap ) {

                switch ( parameters.combine ) {

                        case MultiplyOperation:
                                envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
                                break;

                        case MixOperation:
                                envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
                                break;

                        case AddOperation:
                                envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
                                break;

                }

        }

        return envMapBlendingDefine;

    }

    function WebGLProgram( renderer, cacheKey, parameters, bindingStates ) {

        const gl = renderer.getContext();

        const defines = parameters.defines;

        let vertexShader = parameters.vertexShader;
        let fragmentShader = parameters.fragmentShader;

        const shadowMapTypeDefine = generateShadowMapTypeDefine( parameters );
        const envMapTypeDefine = generateEnvMapTypeDefine( parameters );
        const envMapModeDefine = generateEnvMapModeDefine( parameters );
        const envMapBlendingDefine = generateEnvMapBlendingDefine( parameters );


        const gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0;

        const customExtensions = parameters.isWebGL2 ? '' : generateExtensions( parameters );

        const customDefines = generateDefines( defines );

        const program = gl.createProgram();

        let prefixVertex, prefixFragment;
        let versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\n' : '';

        if ( parameters.isRawShaderMaterial ) {

                prefixVertex = [

                        customDefines

                ].filter( filterEmptyLine ).join( '\n' );

                if ( prefixVertex.length > 0 ) {

                        prefixVertex += '\n';

                }

                prefixFragment = [

                        customExtensions,
                        customDefines

                ].filter( filterEmptyLine ).join( '\n' );

                if ( prefixFragment.length > 0 ) {

                        prefixFragment += '\n';

                }

        } else {

                prefixVertex = [

                        generatePrecision( parameters ),

                        '#define SHADER_NAME ' + parameters.shaderName,

                        customDefines,

                        parameters.instancing ? '#define USE_INSTANCING' : '',
                        parameters.instancingColor ? '#define USE_INSTANCING_COLOR' : '',

                        parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',

                        '#define GAMMA_FACTOR ' + gammaFactorDefine,

                        '#define MAX_BONES ' + parameters.maxBones,
                        ( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',
                        ( parameters.useFog && parameters.fogExp2 ) ? '#define FOG_EXP2' : '',

                        parameters.map ? '#define USE_MAP' : '',
                        parameters.envMap ? '#define USE_ENVMAP' : '',
                        parameters.envMap ? '#define ' + envMapModeDefine : '',
                        parameters.lightMap ? '#define USE_LIGHTMAP' : '',
                        parameters.aoMap ? '#define USE_AOMAP' : '',
                        parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
                        parameters.bumpMap ? '#define USE_BUMPMAP' : '',
                        parameters.normalMap ? '#define USE_NORMALMAP' : '',
                        ( parameters.normalMap && parameters.objectSpaceNormalMap ) ? '#define OBJECTSPACE_NORMALMAP' : '',
                        ( parameters.normalMap && parameters.tangentSpaceNormalMap ) ? '#define TANGENTSPACE_NORMALMAP' : '',

                        parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
                        parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
                        parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
                        parameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '',
                        parameters.specularMap ? '#define USE_SPECULARMAP' : '',
                        parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
                        parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
                        parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
                        parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',

                        parameters.vertexTangents ? '#define USE_TANGENT' : '',
                        parameters.vertexColors ? '#define USE_COLOR' : '',
                        parameters.vertexUvs ? '#define USE_UV' : '',
                        parameters.uvsVertexOnly ? '#define UVS_VERTEX_ONLY' : '',

                        parameters.flatShading ? '#define FLAT_SHADED' : '',

                        parameters.skinning ? '#define USE_SKINNING' : '',
                        parameters.useVertexTexture ? '#define BONE_TEXTURE' : '',

                        parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
                        parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',
                        parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
                        parameters.flipSided ? '#define FLIP_SIDED' : '',

                        parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
                        parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',

                        parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',

                        parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
                        ( parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ) ? '#define USE_LOGDEPTHBUF_EXT' : '',

                        'uniform mat4 modelMatrix;',
                        'uniform mat4 modelViewMatrix;',
                        'uniform mat4 projectionMatrix;',
                        'uniform mat4 viewMatrix;',
                        'uniform mat3 normalMatrix;',
                        'uniform vec3 cameraPosition;',
                        'uniform bool isOrthographic;',

                        '#ifdef USE_INSTANCING',

                        '       attribute mat4 instanceMatrix;',

                        '#endif',

                        '#ifdef USE_INSTANCING_COLOR',

                        '       attribute vec3 instanceColor;',

                        '#endif',

                        'attribute vec3 position;',
                        'attribute vec3 normal;',
                        'attribute vec2 uv;',

                        '#ifdef USE_TANGENT',

                        '       attribute vec4 tangent;',

                        '#endif',

                        '#ifdef USE_COLOR',

                        '       attribute vec3 color;',

                        '#endif',

                        '#ifdef USE_MORPHTARGETS',

                        '       attribute vec3 morphTarget0;',
                        '       attribute vec3 morphTarget1;',
                        '       attribute vec3 morphTarget2;',
                        '       attribute vec3 morphTarget3;',

                        '       #ifdef USE_MORPHNORMALS',

                        '               attribute vec3 morphNormal0;',
                        '               attribute vec3 morphNormal1;',
                        '               attribute vec3 morphNormal2;',
                        '               attribute vec3 morphNormal3;',

                        '       #else',

                        '               attribute vec3 morphTarget4;',
                        '               attribute vec3 morphTarget5;',
                        '               attribute vec3 morphTarget6;',
                        '               attribute vec3 morphTarget7;',

                        '       #endif',

                        '#endif',

                        '#ifdef USE_SKINNING',

                        '       attribute vec4 skinIndex;',
                        '       attribute vec4 skinWeight;',

                        '#endif',

                        '\n'

                ].filter( filterEmptyLine ).join( '\n' );

                prefixFragment = [

                        customExtensions,

                        generatePrecision( parameters ),

                        '#define SHADER_NAME ' + parameters.shaderName,

                        customDefines,

                        parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest + ( parameters.alphaTest % 1 ? '' : '.0' ) : '', // add '.0' if integer

                        '#define GAMMA_FACTOR ' + gammaFactorDefine,

                        ( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',
                        ( parameters.useFog && parameters.fogExp2 ) ? '#define FOG_EXP2' : '',

                        parameters.map ? '#define USE_MAP' : '',
                        parameters.matcap ? '#define USE_MATCAP' : '',
                        parameters.envMap ? '#define USE_ENVMAP' : '',
                        parameters.envMap ? '#define ' + envMapTypeDefine : '',
                        parameters.envMap ? '#define ' + envMapModeDefine : '',
                        parameters.envMap ? '#define ' + envMapBlendingDefine : '',
                        parameters.lightMap ? '#define USE_LIGHTMAP' : '',
                        parameters.aoMap ? '#define USE_AOMAP' : '',
                        parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
                        parameters.bumpMap ? '#define USE_BUMPMAP' : '',
                        parameters.normalMap ? '#define USE_NORMALMAP' : '',
                        ( parameters.normalMap && parameters.objectSpaceNormalMap ) ? '#define OBJECTSPACE_NORMALMAP' : '',
                        ( parameters.normalMap && parameters.tangentSpaceNormalMap ) ? '#define TANGENTSPACE_NORMALMAP' : '',
                        parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
                        parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
                        parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
                        parameters.specularMap ? '#define USE_SPECULARMAP' : '',
                        parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
                        parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
                        parameters.alphaMap ? '#define USE_ALPHAMAP' : '',

                        parameters.sheen ? '#define USE_SHEEN' : '',
                        parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',

                        parameters.vertexTangents ? '#define USE_TANGENT' : '',
                        parameters.vertexColors || parameters.instancingColor ? '#define USE_COLOR' : '',
                        parameters.vertexUvs ? '#define USE_UV' : '',
                        parameters.uvsVertexOnly ? '#define UVS_VERTEX_ONLY' : '',

                        parameters.gradientMap ? '#define USE_GRADIENTMAP' : '',

                        parameters.flatShading ? '#define FLAT_SHADED' : '',

                        parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
                        parameters.flipSided ? '#define FLIP_SIDED' : '',

                        parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
                        parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',

                        parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',

                        parameters.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '',

                        parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
                        ( parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ) ? '#define USE_LOGDEPTHBUF_EXT' : '',

                        ( ( parameters.extensionShaderTextureLOD || parameters.envMap ) && parameters.rendererExtensionShaderTextureLod ) ? '#define TEXTURE_LOD_EXT' : '',

                        'uniform mat4 viewMatrix;',
                        'uniform vec3 cameraPosition;',
                        'uniform bool isOrthographic;',

                        ( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '',
                        ( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below
                        ( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '',

                        parameters.dithering ? '#define DITHERING' : '',

                        ShaderChunk[ 'encodings_pars_fragment' ], // this code is required here because it is used by the various encoding/decoding function defined below
                        parameters.map ? getTexelDecodingFunction( 'mapTexelToLinear', parameters.mapEncoding ) : '',
                        parameters.matcap ? getTexelDecodingFunction( 'matcapTexelToLinear', parameters.matcapEncoding ) : '',
                        parameters.envMap ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',
                        parameters.emissiveMap ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',
                        parameters.lightMap ? getTexelDecodingFunction( 'lightMapTexelToLinear', parameters.lightMapEncoding ) : '',
                        getTexelEncodingFunction( 'linearToOutputTexel', parameters.outputEncoding ),

                        parameters.depthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',

                        '\n'

                ].filter( filterEmptyLine ).join( '\n' );

        }

        vertexShader = resolveIncludes( vertexShader );
        vertexShader = replaceLightNums( vertexShader, parameters );
        vertexShader = replaceClippingPlaneNums( vertexShader, parameters );

        fragmentShader = resolveIncludes( fragmentShader );
        fragmentShader = replaceLightNums( fragmentShader, parameters );
        fragmentShader = replaceClippingPlaneNums( fragmentShader, parameters );

        vertexShader = unrollLoops( vertexShader );
        fragmentShader = unrollLoops( fragmentShader );

        if ( parameters.isWebGL2 && parameters.isRawShaderMaterial !== true ) {

                // GLSL 3.0 conversion for built-in materials and ShaderMaterial

                versionString = '#version 300 es\n';

                prefixVertex = [
                        '#define attribute in',
                        '#define varying out',
                        '#define texture2D texture'
                ].join( '\n' ) + '\n' + prefixVertex;

                prefixFragment = [
                        '#define varying in',
                        ( parameters.glslVersion === GLSL3 ) ? '' : 'out highp vec4 pc_fragColor;',
                        ( parameters.glslVersion === GLSL3 ) ? '' : '#define gl_FragColor pc_fragColor',
                        '#define gl_FragDepthEXT gl_FragDepth',
                        '#define texture2D texture',
                        '#define textureCube texture',
                        '#define texture2DProj textureProj',
                        '#define texture2DLodEXT textureLod',
                        '#define texture2DProjLodEXT textureProjLod',
                        '#define textureCubeLodEXT textureLod',
                        '#define texture2DGradEXT textureGrad',
                        '#define texture2DProjGradEXT textureProjGrad',
                        '#define textureCubeGradEXT textureGrad'
                ].join( '\n' ) + '\n' + prefixFragment;

        }

        const vertexGlsl = versionString + prefixVertex + vertexShader;
        const fragmentGlsl = versionString + prefixFragment + fragmentShader;

        // console.log( '*VERTEX*', vertexGlsl );
        // console.log( '*FRAGMENT*', fragmentGlsl );

        const glVertexShader = WebGLShader( gl, 35633, vertexGlsl );
        const glFragmentShader = WebGLShader( gl, 35632, fragmentGlsl );

        gl.attachShader( program, glVertexShader );
        gl.attachShader( program, glFragmentShader );

        // Force a particular attribute to index 0.

        if ( parameters.index0AttributeName !== undefined ) {

                gl.bindAttribLocation( program, 0, parameters.index0AttributeName );

        } else if ( parameters.morphTargets === true ) {

                // programs with morphTargets displace position out of attribute 0
                gl.bindAttribLocation( program, 0, 'position' );

        }

        gl.linkProgram( program );

        // check for link errors
        if ( renderer.debug.checkShaderErrors ) {

                const programLog = gl.getProgramInfoLog( program ).trim();
                const vertexLog = gl.getShaderInfoLog( glVertexShader ).trim();
                const fragmentLog = gl.getShaderInfoLog( glFragmentShader ).trim();

                let runnable = true;
                let haveDiagnostics = true;

                if ( gl.getProgramParameter( program, 35714 ) === false ) {

                        runnable = false;

                        const vertexErrors = getShaderErrors( gl, glVertexShader, 'vertex' );
                        const fragmentErrors = getShaderErrors( gl, glFragmentShader, 'fragment' );

                        console.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), '35715', gl.getProgramParameter( program, 35715 ), 'gl.getProgramInfoLog', programLog, vertexErrors, fragmentErrors );

                } else if ( programLog !== '' ) {

                        console.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog );

                } else if ( vertexLog === '' || fragmentLog === '' ) {

                        haveDiagnostics = false;

                }

                if ( haveDiagnostics ) {

                        this.diagnostics = {

                                runnable: runnable,

                                programLog: programLog,

                                vertexShader: {

                                        log: vertexLog,
                                        prefix: prefixVertex

                                },

                                fragmentShader: {

                                        log: fragmentLog,
                                        prefix: prefixFragment

                                }

                        };

                }

        }

        // Clean up

        // Crashes in iOS9 and iOS10. #18402
        // gl.detachShader( program, glVertexShader );
        // gl.detachShader( program, glFragmentShader );

        gl.deleteShader( glVertexShader );
        gl.deleteShader( glFragmentShader );

        // set up caching for uniform locations

        let cachedUniforms;

        this.getUniforms = function () {

                if ( cachedUniforms === undefined ) {

                        cachedUniforms = new WebGLUniforms( gl, program );

                }

                return cachedUniforms;

        };

        // set up caching for attribute locations

        let cachedAttributes;

        this.getAttributes = function () {

                if ( cachedAttributes === undefined ) {

                        cachedAttributes = fetchAttributeLocations( gl, program );

                }

                return cachedAttributes;

        };

        // free resource

        this.destroy = function () {

                bindingStates.releaseStatesOfProgram( this );

                gl.deleteProgram( program );
                this.program = undefined;

        };

        //

        this.name = parameters.shaderName;
        this.id = programIdCount ++;
        this.cacheKey = cacheKey;
        this.usedTimes = 1;
        this.program = program;
        this.vertexShader = glVertexShader;
        this.fragmentShader = glFragmentShader;

        return this;

    }

    function WebGLPrograms( renderer, cubemaps, extensions, capabilities, bindingStates, clipping ) {

        const programs = [];

        const isWebGL2 = capabilities.isWebGL2;
        const logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;
        const floatVertexTextures = capabilities.floatVertexTextures;
        const maxVertexUniforms = capabilities.maxVertexUniforms;
        const vertexTextures = capabilities.vertexTextures;

        let precision = capabilities.precision;

        const shaderIDs = {
                MeshDepthMaterial: 'depth',
                MeshDistanceMaterial: 'distanceRGBA',
                MeshNormalMaterial: 'normal',
                MeshBasicMaterial: 'basic',
                MeshLambertMaterial: 'lambert',
                MeshPhongMaterial: 'phong',
                MeshToonMaterial: 'toon',
                MeshStandardMaterial: 'physical',
                MeshPhysicalMaterial: 'physical',
                MeshMatcapMaterial: 'matcap',
                LineBasicMaterial: 'basic',
                LineDashedMaterial: 'dashed',
                PointsMaterial: 'points',
                ShadowMaterial: 'shadow',
                SpriteMaterial: 'sprite'
        };

        const parameterNames = [
                'precision', 'isWebGL2', 'supportsVertexTextures', 'outputEncoding', 'instancing', 'instancingColor',
                'map', 'mapEncoding', 'matcap', 'matcapEncoding', 'envMap', 'envMapMode', 'envMapEncoding', 'envMapCubeUV',
                'lightMap', 'lightMapEncoding', 'aoMap', 'emissiveMap', 'emissiveMapEncoding', 'bumpMap', 'normalMap', 'objectSpaceNormalMap', 'tangentSpaceNormalMap', 'clearcoatMap', 'clearcoatRoughnessMap', 'clearcoatNormalMap', 'displacementMap', 'specularMap',
                'roughnessMap', 'metalnessMap', 'gradientMap',
                'alphaMap', 'combine', 'vertexColors', 'vertexTangents', 'vertexUvs', 'uvsVertexOnly', 'fog', 'useFog', 'fogExp2',
                'flatShading', 'sizeAttenuation', 'logarithmicDepthBuffer', 'skinning',
                'maxBones', 'useVertexTexture', 'morphTargets', 'morphNormals',
                'maxMorphTargets', 'maxMorphNormals', 'premultipliedAlpha',
                'numDirLights', 'numPointLights', 'numSpotLights', 'numHemiLights', 'numRectAreaLights',
                'numDirLightShadows', 'numPointLightShadows', 'numSpotLightShadows',
                'shadowMapEnabled', 'shadowMapType', 'toneMapping', 'physicallyCorrectLights',
                'alphaTest', 'doubleSided', 'flipSided', 'numClippingPlanes', 'numClipIntersection', 'depthPacking', 'dithering',
                'sheen', 'transmissionMap'
        ];

        function getMaxBones( object ) {

                const skeleton = object.skeleton;
                const bones = skeleton.bones;

                if ( floatVertexTextures ) {

                        return 1024;

                } else {

                        // default for when object is not specified
                        // ( for example when prebuilding shader to be used with multiple objects )
                        //
                        //  - leave some extra space for other uniforms
                        //  - limit here is ANGLE's 254 max uniform vectors
                        //    (up to 54 should be safe)

                        const nVertexUniforms = maxVertexUniforms;
                        const nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 );

                        const maxBones = Math.min( nVertexMatrices, bones.length );

                        if ( maxBones < bones.length ) {

                                console.warn( 'THREE.WebGLRenderer: Skeleton has ' + bones.length + ' bones. This GPU supports ' + maxBones + '.' );
                                return 0;

                        }

                        return maxBones;

                }

        }

        function getTextureEncodingFromMap( map ) {

                let encoding;

                if ( map && map.isTexture ) {

                        encoding = map.encoding;

                } else if ( map && map.isWebGLRenderTarget ) {

                        console.warn( 'THREE.WebGLPrograms.getTextureEncodingFromMap: don\'t use render targets as textures. Use their .texture property instead.' );
                        encoding = map.texture.encoding;

                } else {

                        encoding = LinearEncoding;

                }

                return encoding;

        }

        function getParameters( material, lights, shadows, scene, object ) {

                const fog = scene.fog;
                const environment = material.isMeshStandardMaterial ? scene.environment : null;

                const envMap = cubemaps.get( material.envMap || environment );

                const shaderID = shaderIDs[ material.type ];

                // heuristics to create shader parameters according to lights in the scene
                // (not to blow over maxLights budget)

                const maxBones = object.isSkinnedMesh ? getMaxBones( object ) : 0;

                if ( material.precision !== null ) {

                        precision = capabilities.getMaxPrecision( material.precision );

                        if ( precision !== material.precision ) {

                                console.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );

                        }

                }

                let vertexShader, fragmentShader;

                if ( shaderID ) {

                        const shader = ShaderLib[ shaderID ];

                        vertexShader = shader.vertexShader;
                        fragmentShader = shader.fragmentShader;

                } else {

                        vertexShader = material.vertexShader;
                        fragmentShader = material.fragmentShader;

                }

                const currentRenderTarget = renderer.getRenderTarget();

                const parameters = {

                        isWebGL2: isWebGL2,

                        shaderID: shaderID,
                        shaderName: material.type,

                        vertexShader: vertexShader,
                        fragmentShader: fragmentShader,
                        defines: material.defines,

                        isRawShaderMaterial: material.isRawShaderMaterial === true,
                        glslVersion: material.glslVersion,

                        precision: precision,

                        instancing: object.isInstancedMesh === true,
                        instancingColor: object.isInstancedMesh === true && object.instanceColor !== null,

                        supportsVertexTextures: vertexTextures,
                        outputEncoding: ( currentRenderTarget !== null ) ? getTextureEncodingFromMap( currentRenderTarget.texture ) : renderer.outputEncoding,
                        map: !! material.map,
                        mapEncoding: getTextureEncodingFromMap( material.map ),
                        matcap: !! material.matcap,
                        matcapEncoding: getTextureEncodingFromMap( material.matcap ),
                        envMap: !! envMap,
                        envMapMode: envMap && envMap.mapping,
                        envMapEncoding: getTextureEncodingFromMap( envMap ),
                        envMapCubeUV: ( !! envMap ) && ( ( envMap.mapping === CubeUVReflectionMapping ) || ( envMap.mapping === CubeUVRefractionMapping ) ),
                        lightMap: !! material.lightMap,
                        lightMapEncoding: getTextureEncodingFromMap( material.lightMap ),
                        aoMap: !! material.aoMap,
                        emissiveMap: !! material.emissiveMap,
                        emissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap ),
                        bumpMap: !! material.bumpMap,
                        normalMap: !! material.normalMap,
                        objectSpaceNormalMap: material.normalMapType === ObjectSpaceNormalMap,
                        tangentSpaceNormalMap: material.normalMapType === TangentSpaceNormalMap,
                        clearcoatMap: !! material.clearcoatMap,
                        clearcoatRoughnessMap: !! material.clearcoatRoughnessMap,
                        clearcoatNormalMap: !! material.clearcoatNormalMap,
                        displacementMap: !! material.displacementMap,
                        roughnessMap: !! material.roughnessMap,
                        metalnessMap: !! material.metalnessMap,
                        specularMap: !! material.specularMap,
                        alphaMap: !! material.alphaMap,

                        gradientMap: !! material.gradientMap,

                        sheen: !! material.sheen,

                        transmissionMap: !! material.transmissionMap,

                        combine: material.combine,

                        vertexTangents: ( material.normalMap && material.vertexTangents ),
                        vertexColors: material.vertexColors,
                        vertexUvs: !! material.map || !! material.bumpMap || !! material.normalMap || !! material.specularMap || !! material.alphaMap || !! material.emissiveMap || !! material.roughnessMap || !! material.metalnessMap || !! material.clearcoatMap || !! material.clearcoatRoughnessMap || !! material.clearcoatNormalMap || !! material.displacementMap || !! material.transmissionMap,
                        uvsVertexOnly: ! ( !! material.map || !! material.bumpMap || !! material.normalMap || !! material.specularMap || !! material.alphaMap || !! material.emissiveMap || !! material.roughnessMap || !! material.metalnessMap || !! material.clearcoatNormalMap || !! material.transmissionMap ) && !! material.displacementMap,

                        fog: !! fog,
                        useFog: material.fog,
                        fogExp2: ( fog && fog.isFogExp2 ),

                        flatShading: material.flatShading,

                        sizeAttenuation: material.sizeAttenuation,
                        logarithmicDepthBuffer: logarithmicDepthBuffer,

                        skinning: material.skinning && maxBones > 0,
                        maxBones: maxBones,
                        useVertexTexture: floatVertexTextures,

                        morphTargets: material.morphTargets,
                        morphNormals: material.morphNormals,
                        maxMorphTargets: renderer.maxMorphTargets,
                        maxMorphNormals: renderer.maxMorphNormals,

                        numDirLights: lights.directional.length,
                        numPointLights: lights.point.length,
                        numSpotLights: lights.spot.length,
                        numRectAreaLights: lights.rectArea.length,
                        numHemiLights: lights.hemi.length,

                        numDirLightShadows: lights.directionalShadowMap.length,
                        numPointLightShadows: lights.pointShadowMap.length,
                        numSpotLightShadows: lights.spotShadowMap.length,

                        numClippingPlanes: clipping.numPlanes,
                        numClipIntersection: clipping.numIntersection,

                        dithering: material.dithering,

                        shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,
                        shadowMapType: renderer.shadowMap.type,

                        toneMapping: material.toneMapped ? renderer.toneMapping : NoToneMapping,
                        physicallyCorrectLights: renderer.physicallyCorrectLights,

                        premultipliedAlpha: material.premultipliedAlpha,

                        alphaTest: material.alphaTest,
                        doubleSided: material.side === DoubleSide,
                        flipSided: material.side === BackSide,

                        depthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false,

                        index0AttributeName: material.index0AttributeName,

                        extensionDerivatives: material.extensions && material.extensions.derivatives,
                        extensionFragDepth: material.extensions && material.extensions.fragDepth,
                        extensionDrawBuffers: material.extensions && material.extensions.drawBuffers,
                        extensionShaderTextureLOD: material.extensions && material.extensions.shaderTextureLOD,

                        rendererExtensionFragDepth: isWebGL2 || extensions.has( 'EXT_frag_depth' ),
                        rendererExtensionDrawBuffers: isWebGL2 || extensions.has( 'WEBGL_draw_buffers' ),
                        rendererExtensionShaderTextureLod: isWebGL2 || extensions.has( 'EXT_shader_texture_lod' ),

                        customProgramCacheKey: material.customProgramCacheKey()

                };

                return parameters;

        }

        function getProgramCacheKey( parameters ) {

                const array = [];

                if ( parameters.shaderID ) {

                        array.push( parameters.shaderID );

                } else {

                        array.push( parameters.fragmentShader );
                        array.push( parameters.vertexShader );

                }

                if ( parameters.defines !== undefined ) {

                        for ( const name in parameters.defines ) {

                                array.push( name );
                                array.push( parameters.defines[ name ] );

                        }

                }

                if ( parameters.isRawShaderMaterial === false ) {

                        for ( let i = 0; i < parameterNames.length; i ++ ) {

                                array.push( parameters[ parameterNames[ i ] ] );

                        }

                        array.push( renderer.outputEncoding );
                        array.push( renderer.gammaFactor );

                }

                array.push( parameters.customProgramCacheKey );

                return array.join();

        }

        function getUniforms( material ) {

                const shaderID = shaderIDs[ material.type ];
                let uniforms;

                if ( shaderID ) {

                        const shader = ShaderLib[ shaderID ];
                        uniforms = UniformsUtils.clone( shader.uniforms );

                } else {

                        uniforms = material.uniforms;

                }

                return uniforms;

        }

        function acquireProgram( parameters, cacheKey ) {

                let program;

                // Check if code has been already compiled
                for ( let p = 0, pl = programs.length; p < pl; p ++ ) {

                        const preexistingProgram = programs[ p ];

                        if ( preexistingProgram.cacheKey === cacheKey ) {

                                program = preexistingProgram;
                                ++ program.usedTimes;

                                break;

                        }

                }

                if ( program === undefined ) {

                        program = new WebGLProgram( renderer, cacheKey, parameters, bindingStates );
                        programs.push( program );

                }

                return program;

        }

        function releaseProgram( program ) {

                if ( -- program.usedTimes === 0 ) {

                        // Remove from unordered set
                        const i = programs.indexOf( program );
                        programs[ i ] = programs[ programs.length - 1 ];
                        programs.pop();

                        // Free WebGL resources
                        program.destroy();

                }

        }

        return {
                getParameters: getParameters,
                getProgramCacheKey: getProgramCacheKey,
                getUniforms: getUniforms,
                acquireProgram: acquireProgram,
                releaseProgram: releaseProgram,
                // Exposed for resource monitoring & error feedback via renderer.info:
                programs: programs
        };

    }

    function WebGLProperties() {

        let properties = new WeakMap();

        function get( object ) {

                let map = properties.get( object );

                if ( map === undefined ) {

                        map = {};
                        properties.set( object, map );

                }

                return map;

        }

        function remove( object ) {

                properties.delete( object );

        }

        function update( object, key, value ) {

                properties.get( object )[ key ] = value;

        }

        function dispose() {

                properties = new WeakMap();

        }

        return {
                get: get,
                remove: remove,
                update: update,
                dispose: dispose
        };

    }

    function painterSortStable( a, b ) {

        if ( a.groupOrder !== b.groupOrder ) {

                return a.groupOrder - b.groupOrder;

        } else if ( a.renderOrder !== b.renderOrder ) {

                return a.renderOrder - b.renderOrder;

        } else if ( a.program !== b.program ) {

                return a.program.id - b.program.id;

        } else if ( a.material.id !== b.material.id ) {

                return a.material.id - b.material.id;

        } else if ( a.z !== b.z ) {

                return a.z - b.z;

        } else {

                return a.id - b.id;

        }

    }

    function reversePainterSortStable( a, b ) {

        if ( a.groupOrder !== b.groupOrder ) {

                return a.groupOrder - b.groupOrder;

        } else if ( a.renderOrder !== b.renderOrder ) {

                return a.renderOrder - b.renderOrder;

        } else if ( a.z !== b.z ) {

                return b.z - a.z;

        } else {

                return a.id - b.id;

        }

    }


    function WebGLRenderList( properties ) {

        const renderItems = [];
        let renderItemsIndex = 0;

        const opaque = [];
        const transparent = [];

        const defaultProgram = { id: - 1 };

        function init() {

                renderItemsIndex = 0;

                opaque.length = 0;
                transparent.length = 0;

        }

        function getNextRenderItem( object, geometry, material, groupOrder, z, group ) {

                let renderItem = renderItems[ renderItemsIndex ];
                const materialProperties = properties.get( material );

                if ( renderItem === undefined ) {

                        renderItem = {
                                id: object.id,
                                object: object,
                                geometry: geometry,
                                material: material,
                                program: materialProperties.program || defaultProgram,
                                groupOrder: groupOrder,
                                renderOrder: object.renderOrder,
                                z: z,
                                group: group
                        };

                        renderItems[ renderItemsIndex ] = renderItem;

                } else {

                        renderItem.id = object.id;
                        renderItem.object = object;
                        renderItem.geometry = geometry;
                        renderItem.material = material;
                        renderItem.program = materialProperties.program || defaultProgram;
                        renderItem.groupOrder = groupOrder;
                        renderItem.renderOrder = object.renderOrder;
                        renderItem.z = z;
                        renderItem.group = group;

                }

                renderItemsIndex ++;

                return renderItem;

        }

        function push( object, geometry, material, groupOrder, z, group ) {

                const renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );

                ( material.transparent === true ? transparent : opaque ).push( renderItem );

        }

        function unshift( object, geometry, material, groupOrder, z, group ) {

                const renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );

                ( material.transparent === true ? transparent : opaque ).unshift( renderItem );

        }

        function sort( customOpaqueSort, customTransparentSort ) {

                if ( opaque.length > 1 ) opaque.sort( customOpaqueSort || painterSortStable );
                if ( transparent.length > 1 ) transparent.sort( customTransparentSort || reversePainterSortStable );

        }

        function finish() {

                // Clear references from inactive renderItems in the list

                for ( let i = renderItemsIndex, il = renderItems.length; i < il; i ++ ) {

                        const renderItem = renderItems[ i ];

                        if ( renderItem.id === null ) break;

                        renderItem.id = null;
                        renderItem.object = null;
                        renderItem.geometry = null;
                        renderItem.material = null;
                        renderItem.program = null;
                        renderItem.group = null;

                }

        }

        return {

                opaque: opaque,
                transparent: transparent,

                init: init,
                push: push,
                unshift: unshift,
                finish: finish,

                sort: sort
        };

    }

    function WebGLRenderLists( properties ) {

        let lists = new WeakMap();

        function get( scene, camera ) {

                const cameras = lists.get( scene );
                let list;

                if ( cameras === undefined ) {

                        list = new WebGLRenderList( properties );
                        lists.set( scene, new WeakMap() );
                        lists.get( scene ).set( camera, list );

                } else {

                        list = cameras.get( camera );
                        if ( list === undefined ) {

                                list = new WebGLRenderList( properties );
                                cameras.set( camera, list );

                        }

                }

                return list;

        }

        function dispose() {

                lists = new WeakMap();

        }

        return {
                get: get,
                dispose: dispose
        };

    }

    function UniformsCache() {

        const lights = {};

        return {

                get: function ( light ) {

                        if ( lights[ light.id ] !== undefined ) {

                                return lights[ light.id ];

                        }

                        let uniforms;

                        switch ( light.type ) {

                                case 'DirectionalLight':
                                        uniforms = {
                                                direction: new Vector3(),
                                                color: new Color()
                                        };
                                        break;

                                case 'SpotLight':
                                        uniforms = {
                                                position: new Vector3(),
                                                direction: new Vector3(),
                                                color: new Color(),
                                                distance: 0,
                                                coneCos: 0,
                                                penumbraCos: 0,
                                                decay: 0
                                        };
                                        break;

                                case 'PointLight':
                                        uniforms = {
                                                position: new Vector3(),
                                                color: new Color(),
                                                distance: 0,
                                                decay: 0
                                        };
                                        break;

                                case 'HemisphereLight':
                                        uniforms = {
                                                direction: new Vector3(),
                                                skyColor: new Color(),
                                                groundColor: new Color()
                                        };
                                        break;

                                case 'RectAreaLight':
                                        uniforms = {
                                                color: new Color(),
                                                position: new Vector3(),
                                                halfWidth: new Vector3(),
                                                halfHeight: new Vector3()
                                        };
                                        break;

                        }

                        lights[ light.id ] = uniforms;

                        return uniforms;

                }

        };

    }

    function ShadowUniformsCache() {

        const lights = {};

        return {

                get: function ( light ) {

                        if ( lights[ light.id ] !== undefined ) {

                                return lights[ light.id ];

                        }

                        let uniforms;

                        switch ( light.type ) {

                                case 'DirectionalLight':
                                        uniforms = {
                                                shadowBias: 0,
                                                shadowNormalBias: 0,
                                                shadowRadius: 1,
                                                shadowMapSize: new Vector2()
                                        };
                                        break;

                                case 'SpotLight':
                                        uniforms = {
                                                shadowBias: 0,
                                                shadowNormalBias: 0,
                                                shadowRadius: 1,
                                                shadowMapSize: new Vector2()
                                        };
                                        break;

                                case 'PointLight':
                                        uniforms = {
                                                shadowBias: 0,
                                                shadowNormalBias: 0,
                                                shadowRadius: 1,
                                                shadowMapSize: new Vector2(),
                                                shadowCameraNear: 1,
                                                shadowCameraFar: 1000
                                        };
                                        break;

                                // TODO (abelnation): set RectAreaLight shadow uniforms

                        }

                        lights[ light.id ] = uniforms;

                        return uniforms;

                }

        };

    }



    let nextVersion = 0;

    function shadowCastingLightsFirst( lightA, lightB ) {

        return ( lightB.castShadow ? 1 : 0 ) - ( lightA.castShadow ? 1 : 0 );

    }

    function WebGLLights( extensions, capabilities ) {

        const cache = new UniformsCache();

        const shadowCache = ShadowUniformsCache();

        const state = {

                version: 0,

                hash: {
                        directionalLength: - 1,
                        pointLength: - 1,
                        spotLength: - 1,
                        rectAreaLength: - 1,
                        hemiLength: - 1,

                        numDirectionalShadows: - 1,
                        numPointShadows: - 1,
                        numSpotShadows: - 1
                },

                ambient: [ 0, 0, 0 ],
                probe: [],
                directional: [],
                directionalShadow: [],
                directionalShadowMap: [],
                directionalShadowMatrix: [],
                spot: [],
                spotShadow: [],
                spotShadowMap: [],
                spotShadowMatrix: [],
                rectArea: [],
                rectAreaLTC1: null,
                rectAreaLTC2: null,
                point: [],
                pointShadow: [],
                pointShadowMap: [],
                pointShadowMatrix: [],
                hemi: []

        };

        for ( let i = 0; i < 9; i ++ ) state.probe.push( new Vector3() );

        const vector3 = new Vector3();
        const matrix4 = new Matrix4();
        const matrix42 = new Matrix4();

        function setup( lights ) {

                let r = 0, g = 0, b = 0;

                for ( let i = 0; i < 9; i ++ ) state.probe[ i ].set( 0, 0, 0 );

                let directionalLength = 0;
                let pointLength = 0;
                let spotLength = 0;
                let rectAreaLength = 0;
                let hemiLength = 0;

                let numDirectionalShadows = 0;
                let numPointShadows = 0;
                let numSpotShadows = 0;

                lights.sort( shadowCastingLightsFirst );

                for ( let i = 0, l = lights.length; i < l; i ++ ) {

                        const light = lights[ i ];

                        const color = light.color;
                        const intensity = light.intensity;
                        const distance = light.distance;

                        const shadowMap = ( light.shadow && light.shadow.map ) ? light.shadow.map.texture : null;

                        if ( light.isAmbientLight ) {

                                r += color.r * intensity;
                                g += color.g * intensity;
                                b += color.b * intensity;

                        } else if ( light.isLightProbe ) {

                                for ( let j = 0; j < 9; j ++ ) {

                                        state.probe[ j ].addScaledVector( light.sh.coefficients[ j ], intensity );

                                }

                        } else if ( light.isDirectionalLight ) {

                                const uniforms = cache.get( light );

                                uniforms.color.copy( light.color ).multiplyScalar( light.intensity );

                                if ( light.castShadow ) {

                                        const shadow = light.shadow;

                                        const shadowUniforms = shadowCache.get( light );

                                        shadowUniforms.shadowBias = shadow.bias;
                                        shadowUniforms.shadowNormalBias = shadow.normalBias;
                                        shadowUniforms.shadowRadius = shadow.radius;
                                        shadowUniforms.shadowMapSize = shadow.mapSize;

                                        state.directionalShadow[ directionalLength ] = shadowUniforms;
                                        state.directionalShadowMap[ directionalLength ] = shadowMap;
                                        state.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;

                                        numDirectionalShadows ++;

                                }

                                state.directional[ directionalLength ] = uniforms;

                                directionalLength ++;

                        } else if ( light.isSpotLight ) {

                                const uniforms = cache.get( light );

                                uniforms.position.setFromMatrixPosition( light.matrixWorld );

                                uniforms.color.copy( color ).multiplyScalar( intensity );
                                uniforms.distance = distance;

                                uniforms.coneCos = Math.cos( light.angle );
                                uniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );
                                uniforms.decay = light.decay;

                                if ( light.castShadow ) {

                                        const shadow = light.shadow;

                                        const shadowUniforms = shadowCache.get( light );

                                        shadowUniforms.shadowBias = shadow.bias;
                                        shadowUniforms.shadowNormalBias = shadow.normalBias;
                                        shadowUniforms.shadowRadius = shadow.radius;
                                        shadowUniforms.shadowMapSize = shadow.mapSize;

                                        state.spotShadow[ spotLength ] = shadowUniforms;
                                        state.spotShadowMap[ spotLength ] = shadowMap;
                                        state.spotShadowMatrix[ spotLength ] = light.shadow.matrix;

                                        numSpotShadows ++;

                                }

                                state.spot[ spotLength ] = uniforms;

                                spotLength ++;

                        } else if ( light.isRectAreaLight ) {

                                const uniforms = cache.get( light );

                                // (a) intensity is the total visible light emitted
                                //uniforms.color.copy( color ).multiplyScalar( intensity / ( light.width * light.height * Math.PI ) );

                                // (b) intensity is the brightness of the light
                                uniforms.color.copy( color ).multiplyScalar( intensity );

                                uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );
                                uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );

                                state.rectArea[ rectAreaLength ] = uniforms;

                                rectAreaLength ++;

                        } else if ( light.isPointLight ) {

                                const uniforms = cache.get( light );

                                uniforms.color.copy( light.color ).multiplyScalar( light.intensity );
                                uniforms.distance = light.distance;
                                uniforms.decay = light.decay;

                                if ( light.castShadow ) {

                                        const shadow = light.shadow;

                                        const shadowUniforms = shadowCache.get( light );

                                        shadowUniforms.shadowBias = shadow.bias;
                                        shadowUniforms.shadowNormalBias = shadow.normalBias;
                                        shadowUniforms.shadowRadius = shadow.radius;
                                        shadowUniforms.shadowMapSize = shadow.mapSize;
                                        shadowUniforms.shadowCameraNear = shadow.camera.near;
                                        shadowUniforms.shadowCameraFar = shadow.camera.far;

                                        state.pointShadow[ pointLength ] = shadowUniforms;
                                        state.pointShadowMap[ pointLength ] = shadowMap;
                                        state.pointShadowMatrix[ pointLength ] = light.shadow.matrix;

                                        numPointShadows ++;

                                }

                                state.point[ pointLength ] = uniforms;

                                pointLength ++;

                        } else if ( light.isHemisphereLight ) {

                                const uniforms = cache.get( light );

                                uniforms.skyColor.copy( light.color ).multiplyScalar( intensity );
                                uniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity );

                                state.hemi[ hemiLength ] = uniforms;

                                hemiLength ++;

                        }

                }

                if ( rectAreaLength > 0 ) {

                        if ( capabilities.isWebGL2 ) {

                                // WebGL 2

                                state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1;
                                state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2;

                        } else {

                                // WebGL 1

                                if ( extensions.has( 'OES_texture_float_linear' ) === true ) {

                                        state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1;
                                        state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2;

                                } else if ( extensions.has( 'OES_texture_half_float_linear' ) === true ) {

                                        state.rectAreaLTC1 = UniformsLib.LTC_HALF_1;
                                        state.rectAreaLTC2 = UniformsLib.LTC_HALF_2;

                                } else {

                                        console.error( 'THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.' );

                                }

                        }

                }

                state.ambient[ 0 ] = r;
                state.ambient[ 1 ] = g;
                state.ambient[ 2 ] = b;

                const hash = state.hash;

                if ( hash.directionalLength !== directionalLength ||
                        hash.pointLength !== pointLength ||
                        hash.spotLength !== spotLength ||
                        hash.rectAreaLength !== rectAreaLength ||
                        hash.hemiLength !== hemiLength ||
                        hash.numDirectionalShadows !== numDirectionalShadows ||
                        hash.numPointShadows !== numPointShadows ||
                        hash.numSpotShadows !== numSpotShadows ) {

                        state.directional.length = directionalLength;
                        state.spot.length = spotLength;
                        state.rectArea.length = rectAreaLength;
                        state.point.length = pointLength;
                        state.hemi.length = hemiLength;

                        state.directionalShadow.length = numDirectionalShadows;
                        state.directionalShadowMap.length = numDirectionalShadows;
                        state.pointShadow.length = numPointShadows;
                        state.pointShadowMap.length = numPointShadows;
                        state.spotShadow.length = numSpotShadows;
                        state.spotShadowMap.length = numSpotShadows;
                        state.directionalShadowMatrix.length = numDirectionalShadows;
                        state.pointShadowMatrix.length = numPointShadows;
                        state.spotShadowMatrix.length = numSpotShadows;

                        hash.directionalLength = directionalLength;
                        hash.pointLength = pointLength;
                        hash.spotLength = spotLength;
                        hash.rectAreaLength = rectAreaLength;
                        hash.hemiLength = hemiLength;

                        hash.numDirectionalShadows = numDirectionalShadows;
                        hash.numPointShadows = numPointShadows;
                        hash.numSpotShadows = numSpotShadows;

                        state.version = nextVersion ++;

                }

        }

        function setupView( lights, camera ) {

                let directionalLength = 0;
                let pointLength = 0;
                let spotLength = 0;
                let rectAreaLength = 0;
                let hemiLength = 0;

                const viewMatrix = camera.matrixWorldInverse;

                for ( let i = 0, l = lights.length; i < l; i ++ ) {

                        const light = lights[ i ];

                        if ( light.isDirectionalLight ) {

                                const uniforms = state.directional[ directionalLength ];

                                uniforms.direction.setFromMatrixPosition( light.matrixWorld );
                                vector3.setFromMatrixPosition( light.target.matrixWorld );
                                uniforms.direction.sub( vector3 );
                                uniforms.direction.transformDirection( viewMatrix );

                                directionalLength ++;

                        } else if ( light.isSpotLight ) {

                                const uniforms = state.spot[ spotLength ];

                                uniforms.position.setFromMatrixPosition( light.matrixWorld );
                                uniforms.position.applyMatrix4( viewMatrix );

                                uniforms.direction.setFromMatrixPosition( light.matrixWorld );
                                vector3.setFromMatrixPosition( light.target.matrixWorld );
                                uniforms.direction.sub( vector3 );
                                uniforms.direction.transformDirection( viewMatrix );

                                spotLength ++;

                        } else if ( light.isRectAreaLight ) {

                                const uniforms = state.rectArea[ rectAreaLength ];

                                uniforms.position.setFromMatrixPosition( light.matrixWorld );
                                uniforms.position.applyMatrix4( viewMatrix );

                                // extract local rotation of light to derive width/height half vectors
                                matrix42.identity();
                                matrix4.copy( light.matrixWorld );
                                matrix4.premultiply( viewMatrix );
                                matrix42.extractRotation( matrix4 );

                                uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );
                                uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );

                                uniforms.halfWidth.applyMatrix4( matrix42 );
                                uniforms.halfHeight.applyMatrix4( matrix42 );

                                rectAreaLength ++;

                        } else if ( light.isPointLight ) {

                                const uniforms = state.point[ pointLength ];

                                uniforms.position.setFromMatrixPosition( light.matrixWorld );
                                uniforms.position.applyMatrix4( viewMatrix );

                                pointLength ++;

                        } else if ( light.isHemisphereLight ) {

                                const uniforms = state.hemi[ hemiLength ];

                                uniforms.direction.setFromMatrixPosition( light.matrixWorld );
                                uniforms.direction.transformDirection( viewMatrix );
                                uniforms.direction.normalize();

                                hemiLength ++;

                        }

                }

        }

        return {
                setup: setup,
                setupView: setupView,
                state: state
        };

    }

    function WebGLRenderState( extensions, capabilities ) {

        const lights = new WebGLLights( extensions, capabilities );

        const lightsArray = [];
        const shadowsArray = [];

        function init() {

                lightsArray.length = 0;
                shadowsArray.length = 0;

        }

        function pushLight( light ) {

                lightsArray.push( light );

        }

        function pushShadow( shadowLight ) {

                shadowsArray.push( shadowLight );

        }

        function setupLights() {

                lights.setup( lightsArray );

        }

        function setupLightsView( camera ) {

                lights.setupView( lightsArray, camera );

        }

        const state = {
                lightsArray: lightsArray,
                shadowsArray: shadowsArray,

                lights: lights
        };

        return {
                init: init,
                state: state,
                setupLights: setupLights,
                setupLightsView: setupLightsView,

                pushLight: pushLight,
                pushShadow: pushShadow
        };

    }

    function WebGLRenderStates( extensions, capabilities ) {

        let renderStates = new WeakMap();

        function get( scene, renderCallDepth = 0 ) {

                let renderState;

                if ( renderStates.has( scene ) === false ) {

                        renderState = new WebGLRenderState( extensions, capabilities );
                        renderStates.set( scene, [] );
                        renderStates.get( scene ).push( renderState );

                } else {

                        if ( renderCallDepth >= renderStates.get( scene ).length ) {

                                renderState = new WebGLRenderState( extensions, capabilities );
                                renderStates.get( scene ).push( renderState );

                        } else {

                                renderState = renderStates.get( scene )[ renderCallDepth ];

                        }

                }

                return renderState;

        }

        function dispose() {

                renderStates = new WeakMap();

        }

        return {
                get: get,
                dispose: dispose
        };

    }

    /**
     * parameters = {
     *
     *  opacity: <float>,
     *
     *  map: new THREE.Texture( <Image> ),
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>
     * }
     */

    function MeshDepthMaterial( parameters ) {

        Material.call( this );

        this.type = 'MeshDepthMaterial';

        this.depthPacking = BasicDepthPacking;

        this.skinning = false;
        this.morphTargets = false;

        this.map = null;

        this.alphaMap = null;

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.wireframe = false;
        this.wireframeLinewidth = 1;

        this.fog = false;

        this.setValues( parameters );

    }

    MeshDepthMaterial.prototype = Object.create( Material.prototype );
    MeshDepthMaterial.prototype.constructor = MeshDepthMaterial;

    MeshDepthMaterial.prototype.isMeshDepthMaterial = true;

    MeshDepthMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.depthPacking = source.depthPacking;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;

        this.map = source.map;

        this.alphaMap = source.alphaMap;

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;

        return this;

    };

    /**
     * parameters = {
     *
     *  referencePosition: <float>,
     *  nearDistance: <float>,
     *  farDistance: <float>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *
     *  map: new THREE.Texture( <Image> ),
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>
     *
     * }
     */

    function MeshDistanceMaterial( parameters ) {

        Material.call( this );

        this.type = 'MeshDistanceMaterial';

        this.referencePosition = new Vector3();
        this.nearDistance = 1;
        this.farDistance = 1000;

        this.skinning = false;
        this.morphTargets = false;

        this.map = null;

        this.alphaMap = null;

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.fog = false;

        this.setValues( parameters );

    }

    MeshDistanceMaterial.prototype = Object.create( Material.prototype );
    MeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial;

    MeshDistanceMaterial.prototype.isMeshDistanceMaterial = true;

    MeshDistanceMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.referencePosition.copy( source.referencePosition );
        this.nearDistance = source.nearDistance;
        this.farDistance = source.farDistance;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;

        this.map = source.map;

        this.alphaMap = source.alphaMap;

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        return this;

    };

    var vsm_frag = "uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy ) / resolution ) );\n\tfor ( float i = -1.0; i < 1.0 ; i += SAMPLE_RATE) {\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, i ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean * HALF_SAMPLE_RATE;\n\tsquared_mean = squared_mean * HALF_SAMPLE_RATE;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";

    var vsm_vert = "void main() {\n\tgl_Position = vec4( position, 1.0 );\n}";

    function WebGLShadowMap( _renderer, _objects, maxTextureSize ) {

        let _frustum = new Frustum();

        const _shadowMapSize = new Vector2(),
                _viewportSize = new Vector2(),

                _viewport = new Vector4(),

                _depthMaterials = [],
                _distanceMaterials = [],

                _materialCache = {};

        const shadowSide = { 0: BackSide, 1: FrontSide, 2: DoubleSide };

        const shadowMaterialVertical = new ShaderMaterial( {

                defines: {
                        SAMPLE_RATE: 2.0 / 8.0,
                        HALF_SAMPLE_RATE: 1.0 / 8.0
                },

                uniforms: {
                        shadow_pass: { value: null },
                        resolution: { value: new Vector2() },
                        radius: { value: 4.0 }
                },

                vertexShader: vsm_vert,

                fragmentShader: vsm_frag

        } );

        const shadowMaterialHorizontal = shadowMaterialVertical.clone();
        shadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1;

        const fullScreenTri = new BufferGeometry();
        fullScreenTri.setAttribute(
                'position',
                new BufferAttribute(
                        new Float32Array( [ - 1, - 1, 0.5, 3, - 1, 0.5, - 1, 3, 0.5 ] ),
                        3
                )
        );

        const fullScreenMesh = new Mesh( fullScreenTri, shadowMaterialVertical );

        const scope = this;

        this.enabled = false;

        this.autoUpdate = true;
        this.needsUpdate = false;

        this.type = PCFShadowMap;

        this.render = function ( lights, scene, camera ) {

                if ( scope.enabled === false ) return;
                if ( scope.autoUpdate === false && scope.needsUpdate === false ) return;

                if ( lights.length === 0 ) return;

                const currentRenderTarget = _renderer.getRenderTarget();
                const activeCubeFace = _renderer.getActiveCubeFace();
                const activeMipmapLevel = _renderer.getActiveMipmapLevel();

                const _state = _renderer.state;

                // Set GL state for depth map.
                _state.setBlending( NoBlending );
                _state.buffers.color.setClear( 1, 1, 1, 1 );
                _state.buffers.depth.setTest( true );
                _state.setScissorTest( false );

                // render depth map

                for ( let i = 0, il = lights.length; i < il; i ++ ) {

                        const light = lights[ i ];
                        const shadow = light.shadow;

                        if ( shadow === undefined ) {

                                console.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' );
                                continue;

                        }

                        if ( shadow.autoUpdate === false && shadow.needsUpdate === false ) continue;

                        _shadowMapSize.copy( shadow.mapSize );

                        const shadowFrameExtents = shadow.getFrameExtents();

                        _shadowMapSize.multiply( shadowFrameExtents );

                        _viewportSize.copy( shadow.mapSize );

                        if ( _shadowMapSize.x > maxTextureSize || _shadowMapSize.y > maxTextureSize ) {

                                if ( _shadowMapSize.x > maxTextureSize ) {

                                        _viewportSize.x = Math.floor( maxTextureSize / shadowFrameExtents.x );
                                        _shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x;
                                        shadow.mapSize.x = _viewportSize.x;

                                }

                                if ( _shadowMapSize.y > maxTextureSize ) {

                                        _viewportSize.y = Math.floor( maxTextureSize / shadowFrameExtents.y );
                                        _shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y;
                                        shadow.mapSize.y = _viewportSize.y;

                                }

                        }

                        if ( shadow.map === null && ! shadow.isPointLightShadow && this.type === VSMShadowMap ) {

                                const pars = { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat };

                                shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
                                shadow.map.texture.name = light.name + '.shadowMap';

                                shadow.mapPass = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );

                                shadow.camera.updateProjectionMatrix();

                        }

                        if ( shadow.map === null ) {

                                const pars = { minFilter: NearestFilter, magFilter: NearestFilter, format: RGBAFormat };

                                shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
                                shadow.map.texture.name = light.name + '.shadowMap';

                                shadow.camera.updateProjectionMatrix();

                        }

                        _renderer.setRenderTarget( shadow.map );
                        _renderer.clear();

                        const viewportCount = shadow.getViewportCount();

                        for ( let vp = 0; vp < viewportCount; vp ++ ) {

                                const viewport = shadow.getViewport( vp );

                                _viewport.set(
                                        _viewportSize.x * viewport.x,
                                        _viewportSize.y * viewport.y,
                                        _viewportSize.x * viewport.z,
                                        _viewportSize.y * viewport.w
                                );

                                _state.viewport( _viewport );

                                shadow.updateMatrices( light, vp );

                                _frustum = shadow.getFrustum();

                                renderObject( scene, camera, shadow.camera, light, this.type );

                        }

                        // do blur pass for VSM

                        if ( ! shadow.isPointLightShadow && this.type === VSMShadowMap ) {

                                VSMPass( shadow, camera );

                        }

                        shadow.needsUpdate = false;

                }

                scope.needsUpdate = false;

                _renderer.setRenderTarget( currentRenderTarget, activeCubeFace, activeMipmapLevel );

        };

        function VSMPass( shadow, camera ) {

                const geometry = _objects.update( fullScreenMesh );

                // vertical pass

                shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture;
                shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize;
                shadowMaterialVertical.uniforms.radius.value = shadow.radius;
                _renderer.setRenderTarget( shadow.mapPass );
                _renderer.clear();
                _renderer.renderBufferDirect( camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null );

                // horizontal pass

                shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture;
                shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize;
                shadowMaterialHorizontal.uniforms.radius.value = shadow.radius;
                _renderer.setRenderTarget( shadow.map );
                _renderer.clear();
                _renderer.renderBufferDirect( camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null );

        }

        function getDepthMaterialVariant( useMorphing, useSkinning, useInstancing ) {

                const index = useMorphing << 0 | useSkinning << 1 | useInstancing << 2;

                let material = _depthMaterials[ index ];

                if ( material === undefined ) {

                        material = new MeshDepthMaterial( {

                                depthPacking: RGBADepthPacking,

                                morphTargets: useMorphing,
                                skinning: useSkinning

                        } );

                        _depthMaterials[ index ] = material;

                }

                return material;

        }

        function getDistanceMaterialVariant( useMorphing, useSkinning, useInstancing ) {

                const index = useMorphing << 0 | useSkinning << 1 | useInstancing << 2;

                let material = _distanceMaterials[ index ];

                if ( material === undefined ) {

                        material = new MeshDistanceMaterial( {

                                morphTargets: useMorphing,
                                skinning: useSkinning

                        } );

                        _distanceMaterials[ index ] = material;

                }

                return material;

        }

        function getDepthMaterial( object, geometry, material, light, shadowCameraNear, shadowCameraFar, type ) {

                let result = null;

                let getMaterialVariant = getDepthMaterialVariant;
                let customMaterial = object.customDepthMaterial;

                if ( light.isPointLight === true ) {

                        getMaterialVariant = getDistanceMaterialVariant;
                        customMaterial = object.customDistanceMaterial;

                }

                if ( customMaterial === undefined ) {

                        let useMorphing = false;

                        if ( material.morphTargets === true ) {

                                useMorphing = geometry.morphAttributes && geometry.morphAttributes.position && geometry.morphAttributes.position.length > 0;

                        }

                        let useSkinning = false;

                        if ( object.isSkinnedMesh === true ) {

                                if ( material.skinning === true ) {

                                        useSkinning = true;

                                } else {

                                        console.warn( 'THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:', object );

                                }

                        }

                        const useInstancing = object.isInstancedMesh === true;

                        result = getMaterialVariant( useMorphing, useSkinning, useInstancing );

                } else {

                        result = customMaterial;

                }

                if ( _renderer.localClippingEnabled &&
                                material.clipShadows === true &&
                                material.clippingPlanes.length !== 0 ) {

                        // in this case we need a unique material instance reflecting the
                        // appropriate state

                        const keyA = result.uuid, keyB = material.uuid;

                        let materialsForVariant = _materialCache[ keyA ];

                        if ( materialsForVariant === undefined ) {

                                materialsForVariant = {};
                                _materialCache[ keyA ] = materialsForVariant;

                        }

                        let cachedMaterial = materialsForVariant[ keyB ];

                        if ( cachedMaterial === undefined ) {

                                cachedMaterial = result.clone();
                                materialsForVariant[ keyB ] = cachedMaterial;

                        }

                        result = cachedMaterial;

                }

                result.visible = material.visible;
                result.wireframe = material.wireframe;

                if ( type === VSMShadowMap ) {

                        result.side = ( material.shadowSide !== null ) ? material.shadowSide : material.side;

                } else {

                        result.side = ( material.shadowSide !== null ) ? material.shadowSide : shadowSide[ material.side ];

                }

                result.clipShadows = material.clipShadows;
                result.clippingPlanes = material.clippingPlanes;
                result.clipIntersection = material.clipIntersection;

                result.wireframeLinewidth = material.wireframeLinewidth;
                result.linewidth = material.linewidth;

                if ( light.isPointLight === true && result.isMeshDistanceMaterial === true ) {

                        result.referencePosition.setFromMatrixPosition( light.matrixWorld );
                        result.nearDistance = shadowCameraNear;
                        result.farDistance = shadowCameraFar;

                }

                return result;

        }

        function renderObject( object, camera, shadowCamera, light, type ) {

                if ( object.visible === false ) return;

                const visible = object.layers.test( camera.layers );

                if ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {

                        if ( ( object.castShadow || ( object.receiveShadow && type === VSMShadowMap ) ) && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {

                                object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );

                                const geometry = _objects.update( object );
                                const material = object.material;

                                if ( Array.isArray( material ) ) {

                                        const groups = geometry.groups;

                                        for ( let k = 0, kl = groups.length; k < kl; k ++ ) {

                                                const group = groups[ k ];
                                                const groupMaterial = material[ group.materialIndex ];

                                                if ( groupMaterial && groupMaterial.visible ) {

                                                        const depthMaterial = getDepthMaterial( object, geometry, groupMaterial, light, shadowCamera.near, shadowCamera.far, type );

                                                        _renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );

                                                }

                                        }

                                } else if ( material.visible ) {

                                        const depthMaterial = getDepthMaterial( object, geometry, material, light, shadowCamera.near, shadowCamera.far, type );

                                        _renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );

                                }

                        }

                }

                const children = object.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        renderObject( children[ i ], camera, shadowCamera, light, type );

                }

        }

    }

    function WebGLState( gl, extensions, capabilities ) {

        const isWebGL2 = capabilities.isWebGL2;

        function ColorBuffer() {

                let locked = false;

                const color = new Vector4();
                let currentColorMask = null;
                const currentColorClear = new Vector4( 0, 0, 0, 0 );

                return {

                        setMask: function ( colorMask ) {

                                if ( currentColorMask !== colorMask && ! locked ) {

                                        gl.colorMask( colorMask, colorMask, colorMask, colorMask );
                                        currentColorMask = colorMask;

                                }

                        },

                        setLocked: function ( lock ) {

                                locked = lock;

                        },

                        setClear: function ( r, g, b, a, premultipliedAlpha ) {

                                if ( premultipliedAlpha === true ) {

                                        r *= a; g *= a; b *= a;

                                }

                                color.set( r, g, b, a );

                                if ( currentColorClear.equals( color ) === false ) {

                                        gl.clearColor( r, g, b, a );
                                        currentColorClear.copy( color );

                                }

                        },

                        reset: function () {

                                locked = false;

                                currentColorMask = null;
                                currentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state

                        }

                };

        }

        function DepthBuffer() {

                let locked = false;

                let currentDepthMask = null;
                let currentDepthFunc = null;
                let currentDepthClear = null;

                return {

                        setTest: function ( depthTest ) {

                                if ( depthTest ) {

                                        enable( 2929 );

                                } else {

                                        disable( 2929 );

                                }

                        },

                        setMask: function ( depthMask ) {

                                if ( currentDepthMask !== depthMask && ! locked ) {

                                        gl.depthMask( depthMask );
                                        currentDepthMask = depthMask;

                                }

                        },

                        setFunc: function ( depthFunc ) {

                                if ( currentDepthFunc !== depthFunc ) {

                                        if ( depthFunc ) {

                                                switch ( depthFunc ) {

                                                        case NeverDepth:

                                                                gl.depthFunc( 512 );
                                                                break;

                                                        case AlwaysDepth:

                                                                gl.depthFunc( 519 );
                                                                break;

                                                        case LessDepth:

                                                                gl.depthFunc( 513 );
                                                                break;

                                                        case LessEqualDepth:

                                                                gl.depthFunc( 515 );
                                                                break;

                                                        case EqualDepth:

                                                                gl.depthFunc( 514 );
                                                                break;

                                                        case GreaterEqualDepth:

                                                                gl.depthFunc( 518 );
                                                                break;

                                                        case GreaterDepth:

                                                                gl.depthFunc( 516 );
                                                                break;

                                                        case NotEqualDepth:

                                                                gl.depthFunc( 517 );
                                                                break;

                                                        default:

                                                                gl.depthFunc( 515 );

                                                }

                                        } else {

                                                gl.depthFunc( 515 );

                                        }

                                        currentDepthFunc = depthFunc;

                                }

                        },

                        setLocked: function ( lock ) {

                                locked = lock;

                        },

                        setClear: function ( depth ) {

                                if ( currentDepthClear !== depth ) {

                                        gl.clearDepth( depth );
                                        currentDepthClear = depth;

                                }

                        },

                        reset: function () {

                                locked = false;

                                currentDepthMask = null;
                                currentDepthFunc = null;
                                currentDepthClear = null;

                        }

                };

        }

        function StencilBuffer() {

                let locked = false;

                let currentStencilMask = null;
                let currentStencilFunc = null;
                let currentStencilRef = null;
                let currentStencilFuncMask = null;
                let currentStencilFail = null;
                let currentStencilZFail = null;
                let currentStencilZPass = null;
                let currentStencilClear = null;

                return {

                        setTest: function ( stencilTest ) {

                                if ( ! locked ) {

                                        if ( stencilTest ) {

                                                enable( 2960 );

                                        } else {

                                                disable( 2960 );

                                        }

                                }

                        },

                        setMask: function ( stencilMask ) {

                                if ( currentStencilMask !== stencilMask && ! locked ) {

                                        gl.stencilMask( stencilMask );
                                        currentStencilMask = stencilMask;

                                }

                        },

                        setFunc: function ( stencilFunc, stencilRef, stencilMask ) {

                                if ( currentStencilFunc !== stencilFunc ||
                                     currentStencilRef !== stencilRef ||
                                     currentStencilFuncMask !== stencilMask ) {

                                        gl.stencilFunc( stencilFunc, stencilRef, stencilMask );

                                        currentStencilFunc = stencilFunc;
                                        currentStencilRef = stencilRef;
                                        currentStencilFuncMask = stencilMask;

                                }

                        },

                        setOp: function ( stencilFail, stencilZFail, stencilZPass ) {

                                if ( currentStencilFail !== stencilFail ||
                                     currentStencilZFail !== stencilZFail ||
                                     currentStencilZPass !== stencilZPass ) {

                                        gl.stencilOp( stencilFail, stencilZFail, stencilZPass );

                                        currentStencilFail = stencilFail;
                                        currentStencilZFail = stencilZFail;
                                        currentStencilZPass = stencilZPass;

                                }

                        },

                        setLocked: function ( lock ) {

                                locked = lock;

                        },

                        setClear: function ( stencil ) {

                                if ( currentStencilClear !== stencil ) {

                                        gl.clearStencil( stencil );
                                        currentStencilClear = stencil;

                                }

                        },

                        reset: function () {

                                locked = false;

                                currentStencilMask = null;
                                currentStencilFunc = null;
                                currentStencilRef = null;
                                currentStencilFuncMask = null;
                                currentStencilFail = null;
                                currentStencilZFail = null;
                                currentStencilZPass = null;
                                currentStencilClear = null;

                        }

                };

        }

        //

        const colorBuffer = new ColorBuffer();
        const depthBuffer = new DepthBuffer();
        const stencilBuffer = new StencilBuffer();

        let enabledCapabilities = {};

        let currentProgram = null;

        let currentBlendingEnabled = null;
        let currentBlending = null;
        let currentBlendEquation = null;
        let currentBlendSrc = null;
        let currentBlendDst = null;
        let currentBlendEquationAlpha = null;
        let currentBlendSrcAlpha = null;
        let currentBlendDstAlpha = null;
        let currentPremultipledAlpha = false;

        let currentFlipSided = null;
        let currentCullFace = null;

        let currentLineWidth = null;

        let currentPolygonOffsetFactor = null;
        let currentPolygonOffsetUnits = null;

        const maxTextures = gl.getParameter( 35661 );

        let lineWidthAvailable = false;
        let version = 0;
        const glVersion = gl.getParameter( 7938 );

        if ( glVersion.indexOf( 'WebGL' ) !== - 1 ) {

                version = parseFloat( /^WebGL (\d)/.exec( glVersion )[ 1 ] );
                lineWidthAvailable = ( version >= 1.0 );

        } else if ( glVersion.indexOf( 'OpenGL ES' ) !== - 1 ) {

                version = parseFloat( /^OpenGL ES (\d)/.exec( glVersion )[ 1 ] );
                lineWidthAvailable = ( version >= 2.0 );

        }

        let currentTextureSlot = null;
        let currentBoundTextures = {};

        const currentScissor = new Vector4();
        const currentViewport = new Vector4();

        function createTexture( type, target, count ) {

                const data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4.
                const texture = gl.createTexture();

                gl.bindTexture( type, texture );
                gl.texParameteri( type, 10241, 9728 );
                gl.texParameteri( type, 10240, 9728 );

                for ( let i = 0; i < count; i ++ ) {

                        gl.texImage2D( target + i, 0, 6408, 1, 1, 0, 6408, 5121, data );

                }

                return texture;

        }

        const emptyTextures = {};
        emptyTextures[ 3553 ] = createTexture( 3553, 3553, 1 );
        emptyTextures[ 34067 ] = createTexture( 34067, 34069, 6 );

        // init

        colorBuffer.setClear( 0, 0, 0, 1 );
        depthBuffer.setClear( 1 );
        stencilBuffer.setClear( 0 );

        enable( 2929 );
        depthBuffer.setFunc( LessEqualDepth );

        setFlipSided( false );
        setCullFace( CullFaceBack );
        enable( 2884 );

        setBlending( NoBlending );

        //

        function enable( id ) {

                if ( enabledCapabilities[ id ] !== true ) {

                        gl.enable( id );
                        enabledCapabilities[ id ] = true;

                }

        }

        function disable( id ) {

                if ( enabledCapabilities[ id ] !== false ) {

                        gl.disable( id );
                        enabledCapabilities[ id ] = false;

                }

        }

        function useProgram( program ) {

                if ( currentProgram !== program ) {

                        gl.useProgram( program );

                        currentProgram = program;

                        return true;

                }

                return false;

        }

        const equationToGL = {
                [ AddEquation ]: 32774,
                [ SubtractEquation ]: 32778,
                [ ReverseSubtractEquation ]: 32779
        };

        if ( isWebGL2 ) {

                equationToGL[ MinEquation ] = 32775;
                equationToGL[ MaxEquation ] = 32776;

        } else {

                const extension = extensions.get( 'EXT_blend_minmax' );

                if ( extension !== null ) {

                        equationToGL[ MinEquation ] = extension.MIN_EXT;
                        equationToGL[ MaxEquation ] = extension.MAX_EXT;

                }

        }

        const factorToGL = {
                [ ZeroFactor ]: 0,
                [ OneFactor ]: 1,
                [ SrcColorFactor ]: 768,
                [ SrcAlphaFactor ]: 770,
                [ SrcAlphaSaturateFactor ]: 776,
                [ DstColorFactor ]: 774,
                [ DstAlphaFactor ]: 772,
                [ OneMinusSrcColorFactor ]: 769,
                [ OneMinusSrcAlphaFactor ]: 771,
                [ OneMinusDstColorFactor ]: 775,
                [ OneMinusDstAlphaFactor ]: 773
        };

        function setBlending( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha ) {

                if ( blending === NoBlending ) {

                        if ( currentBlendingEnabled ) {

                                disable( 3042 );
                                currentBlendingEnabled = false;

                        }

                        return;

                }

                if ( ! currentBlendingEnabled ) {

                        enable( 3042 );
                        currentBlendingEnabled = true;

                }

                if ( blending !== CustomBlending ) {

                        if ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {

                                if ( currentBlendEquation !== AddEquation || currentBlendEquationAlpha !== AddEquation ) {

                                        gl.blendEquation( 32774 );

                                        currentBlendEquation = AddEquation;
                                        currentBlendEquationAlpha = AddEquation;

                                }

                                if ( premultipliedAlpha ) {

                                        switch ( blending ) {

                                                case NormalBlending:
                                                        gl.blendFuncSeparate( 1, 771, 1, 771 );
                                                        break;

                                                case AdditiveBlending:
                                                        gl.blendFunc( 1, 1 );
                                                        break;

                                                case SubtractiveBlending:
                                                        gl.blendFuncSeparate( 0, 0, 769, 771 );
                                                        break;

                                                case MultiplyBlending:
                                                        gl.blendFuncSeparate( 0, 768, 0, 770 );
                                                        break;

                                                default:
                                                        console.error( 'THREE.WebGLState: Invalid blending: ', blending );
                                                        break;

                                        }

                                } else {

                                        switch ( blending ) {

                                                case NormalBlending:
                                                        gl.blendFuncSeparate( 770, 771, 1, 771 );
                                                        break;

                                                case AdditiveBlending:
                                                        gl.blendFunc( 770, 1 );
                                                        break;

                                                case SubtractiveBlending:
                                                        gl.blendFunc( 0, 769 );
                                                        break;

                                                case MultiplyBlending:
                                                        gl.blendFunc( 0, 768 );
                                                        break;

                                                default:
                                                        console.error( 'THREE.WebGLState: Invalid blending: ', blending );
                                                        break;

                                        }

                                }

                                currentBlendSrc = null;
                                currentBlendDst = null;
                                currentBlendSrcAlpha = null;
                                currentBlendDstAlpha = null;

                                currentBlending = blending;
                                currentPremultipledAlpha = premultipliedAlpha;

                        }

                        return;

                }

                // custom blending

                blendEquationAlpha = blendEquationAlpha || blendEquation;
                blendSrcAlpha = blendSrcAlpha || blendSrc;
                blendDstAlpha = blendDstAlpha || blendDst;

                if ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {

                        gl.blendEquationSeparate( equationToGL[ blendEquation ], equationToGL[ blendEquationAlpha ] );

                        currentBlendEquation = blendEquation;
                        currentBlendEquationAlpha = blendEquationAlpha;

                }

                if ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {

                        gl.blendFuncSeparate( factorToGL[ blendSrc ], factorToGL[ blendDst ], factorToGL[ blendSrcAlpha ], factorToGL[ blendDstAlpha ] );

                        currentBlendSrc = blendSrc;
                        currentBlendDst = blendDst;
                        currentBlendSrcAlpha = blendSrcAlpha;
                        currentBlendDstAlpha = blendDstAlpha;

                }

                currentBlending = blending;
                currentPremultipledAlpha = null;

        }

        function setMaterial( material, frontFaceCW ) {

                material.side === DoubleSide
                        ? disable( 2884 )
                        : enable( 2884 );

                let flipSided = ( material.side === BackSide );
                if ( frontFaceCW ) flipSided = ! flipSided;

                setFlipSided( flipSided );

                ( material.blending === NormalBlending && material.transparent === false )
                        ? setBlending( NoBlending )
                        : setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha );

                depthBuffer.setFunc( material.depthFunc );
                depthBuffer.setTest( material.depthTest );
                depthBuffer.setMask( material.depthWrite );
                colorBuffer.setMask( material.colorWrite );

                const stencilWrite = material.stencilWrite;
                stencilBuffer.setTest( stencilWrite );
                if ( stencilWrite ) {

                        stencilBuffer.setMask( material.stencilWriteMask );
                        stencilBuffer.setFunc( material.stencilFunc, material.stencilRef, material.stencilFuncMask );
                        stencilBuffer.setOp( material.stencilFail, material.stencilZFail, material.stencilZPass );

                }

                setPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );

        }

        //

        function setFlipSided( flipSided ) {

                if ( currentFlipSided !== flipSided ) {

                        if ( flipSided ) {

                                gl.frontFace( 2304 );

                        } else {

                                gl.frontFace( 2305 );

                        }

                        currentFlipSided = flipSided;

                }

        }

        function setCullFace( cullFace ) {

                if ( cullFace !== CullFaceNone ) {

                        enable( 2884 );

                        if ( cullFace !== currentCullFace ) {

                                if ( cullFace === CullFaceBack ) {

                                        gl.cullFace( 1029 );

                                } else if ( cullFace === CullFaceFront ) {

                                        gl.cullFace( 1028 );

                                } else {

                                        gl.cullFace( 1032 );

                                }

                        }

                } else {

                        disable( 2884 );

                }

                currentCullFace = cullFace;

        }

        function setLineWidth( width ) {

                if ( width !== currentLineWidth ) {

                        if ( lineWidthAvailable ) gl.lineWidth( width );

                        currentLineWidth = width;

                }

        }

        function setPolygonOffset( polygonOffset, factor, units ) {

                if ( polygonOffset ) {

                        enable( 32823 );

                        if ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) {

                                gl.polygonOffset( factor, units );

                                currentPolygonOffsetFactor = factor;
                                currentPolygonOffsetUnits = units;

                        }

                } else {

                        disable( 32823 );

                }

        }

        function setScissorTest( scissorTest ) {

                if ( scissorTest ) {

                        enable( 3089 );

                } else {

                        disable( 3089 );

                }

        }

        // texture

        function activeTexture( webglSlot ) {

                if ( webglSlot === undefined ) webglSlot = 33984 + maxTextures - 1;

                if ( currentTextureSlot !== webglSlot ) {

                        gl.activeTexture( webglSlot );
                        currentTextureSlot = webglSlot;

                }

        }

        function bindTexture( webglType, webglTexture ) {

                if ( currentTextureSlot === null ) {

                        activeTexture();

                }

                let boundTexture = currentBoundTextures[ currentTextureSlot ];

                if ( boundTexture === undefined ) {

                        boundTexture = { type: undefined, texture: undefined };
                        currentBoundTextures[ currentTextureSlot ] = boundTexture;

                }

                if ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {

                        gl.bindTexture( webglType, webglTexture || emptyTextures[ webglType ] );

                        boundTexture.type = webglType;
                        boundTexture.texture = webglTexture;

                }

        }

        function unbindTexture() {

                const boundTexture = currentBoundTextures[ currentTextureSlot ];

                if ( boundTexture !== undefined && boundTexture.type !== undefined ) {

                        gl.bindTexture( boundTexture.type, null );

                        boundTexture.type = undefined;
                        boundTexture.texture = undefined;

                }

        }

        function compressedTexImage2D() {

                try {

                        gl.compressedTexImage2D.apply( gl, arguments );

                } catch ( error ) {

                        console.error( 'THREE.WebGLState:', error );

                }

        }

        function texImage2D() {

                try {

                        gl.texImage2D.apply( gl, arguments );

                } catch ( error ) {

                        console.error( 'THREE.WebGLState:', error );

                }

        }

        function texImage3D() {

                try {

                        gl.texImage3D.apply( gl, arguments );

                } catch ( error ) {

                        console.error( 'THREE.WebGLState:', error );

                }

        }

        //

        function scissor( scissor ) {

                if ( currentScissor.equals( scissor ) === false ) {

                        gl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );
                        currentScissor.copy( scissor );

                }

        }

        function viewport( viewport ) {

                if ( currentViewport.equals( viewport ) === false ) {

                        gl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );
                        currentViewport.copy( viewport );

                }

        }

        //

        function reset() {

                enabledCapabilities = {};

                currentTextureSlot = null;
                currentBoundTextures = {};

                currentProgram = null;

                currentBlendingEnabled = null;
                currentBlending = null;
                currentBlendEquation = null;
                currentBlendSrc = null;
                currentBlendDst = null;
                currentBlendEquationAlpha = null;
                currentBlendSrcAlpha = null;
                currentBlendDstAlpha = null;
                currentPremultipledAlpha = false;

                currentFlipSided = null;
                currentCullFace = null;

                currentLineWidth = null;

                currentPolygonOffsetFactor = null;
                currentPolygonOffsetUnits = null;

                colorBuffer.reset();
                depthBuffer.reset();
                stencilBuffer.reset();

        }

        return {

                buffers: {
                        color: colorBuffer,
                        depth: depthBuffer,
                        stencil: stencilBuffer
                },

                enable: enable,
                disable: disable,

                useProgram: useProgram,

                setBlending: setBlending,
                setMaterial: setMaterial,

                setFlipSided: setFlipSided,
                setCullFace: setCullFace,

                setLineWidth: setLineWidth,
                setPolygonOffset: setPolygonOffset,

                setScissorTest: setScissorTest,

                activeTexture: activeTexture,
                bindTexture: bindTexture,
                unbindTexture: unbindTexture,
                compressedTexImage2D: compressedTexImage2D,
                texImage2D: texImage2D,
                texImage3D: texImage3D,

                scissor: scissor,
                viewport: viewport,

                reset: reset

        };

    }

    function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info ) {

        const isWebGL2 = capabilities.isWebGL2;
        const maxTextures = capabilities.maxTextures;
        const maxCubemapSize = capabilities.maxCubemapSize;
        const maxTextureSize = capabilities.maxTextureSize;
        const maxSamples = capabilities.maxSamples;

        const _videoTextures = new WeakMap();
        let _canvas;

        // cordova iOS (as of 5.0) still uses UIWebView, which provides OffscreenCanvas,
        // also OffscreenCanvas.getContext("webgl"), but not OffscreenCanvas.getContext("2d")!
        // Some implementations may only implement OffscreenCanvas partially (e.g. lacking 2d).

        let useOffscreenCanvas = false;

        try {

                useOffscreenCanvas = typeof OffscreenCanvas !== 'undefined'
                        && ( new OffscreenCanvas( 1, 1 ).getContext( '2d' ) ) !== null;

        } catch ( err ) {

                // Ignore any errors

        }

        function createCanvas( width, height ) {

                // Use OffscreenCanvas when available. Specially needed in web workers

                return useOffscreenCanvas ?
                        new OffscreenCanvas( width, height ) :
                        document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );

        }

        function resizeImage( image, needsPowerOfTwo, needsNewCanvas, maxSize ) {

                let scale = 1;

                // handle case if texture exceeds max size

                if ( image.width > maxSize || image.height > maxSize ) {

                        scale = maxSize / Math.max( image.width, image.height );

                }

                // only perform resize if necessary

                if ( scale < 1 || needsPowerOfTwo === true ) {

                        // only perform resize for certain image types

                        if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
                                ( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
                                ( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {

                                const floor = needsPowerOfTwo ? MathUtils.floorPowerOfTwo : Math.floor;

                                const width = floor( scale * image.width );
                                const height = floor( scale * image.height );

                                if ( _canvas === undefined ) _canvas = createCanvas( width, height );

                                // cube textures can't reuse the same canvas

                                const canvas = needsNewCanvas ? createCanvas( width, height ) : _canvas;

                                canvas.width = width;
                                canvas.height = height;

                                const context = canvas.getContext( '2d' );
                                context.drawImage( image, 0, 0, width, height );

                                console.warn( 'THREE.WebGLRenderer: Texture has been resized from (' + image.width + 'x' + image.height + ') to (' + width + 'x' + height + ').' );

                                return canvas;

                        } else {

                                if ( 'data' in image ) {

                                        console.warn( 'THREE.WebGLRenderer: Image in DataTexture is too big (' + image.width + 'x' + image.height + ').' );

                                }

                                return image;

                        }

                }

                return image;

        }

        function isPowerOfTwo( image ) {

                return MathUtils.isPowerOfTwo( image.width ) && MathUtils.isPowerOfTwo( image.height );

        }

        function textureNeedsPowerOfTwo( texture ) {

                if ( isWebGL2 ) return false;

                return ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) ||
                        ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter );

        }

        function textureNeedsGenerateMipmaps( texture, supportsMips ) {

                return texture.generateMipmaps && supportsMips &&
                        texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;

        }

        function generateMipmap( target, texture, width, height ) {

                _gl.generateMipmap( target );

                const textureProperties = properties.get( texture );

                // Note: Math.log( x ) * Math.LOG2E used instead of Math.log2( x ) which is not supported by IE11
                textureProperties.__maxMipLevel = Math.log( Math.max( width, height ) ) * Math.LOG2E;

        }

        function getInternalFormat( internalFormatName, glFormat, glType ) {

                if ( isWebGL2 === false ) return glFormat;

                if ( internalFormatName !== null ) {

                        if ( _gl[ internalFormatName ] !== undefined ) return _gl[ internalFormatName ];

                        console.warn( 'THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format \'' + internalFormatName + '\'' );

                }

                let internalFormat = glFormat;

                if ( glFormat === 6403 ) {

                        if ( glType === 5126 ) internalFormat = 33326;
                        if ( glType === 5131 ) internalFormat = 33325;
                        if ( glType === 5121 ) internalFormat = 33321;

                }

                if ( glFormat === 6407 ) {

                        if ( glType === 5126 ) internalFormat = 34837;
                        if ( glType === 5131 ) internalFormat = 34843;
                        if ( glType === 5121 ) internalFormat = 32849;

                }

                if ( glFormat === 6408 ) {

                        if ( glType === 5126 ) internalFormat = 34836;
                        if ( glType === 5131 ) internalFormat = 34842;
                        if ( glType === 5121 ) internalFormat = 32856;

                }

                if ( internalFormat === 33325 || internalFormat === 33326 ||
                        internalFormat === 34842 || internalFormat === 34836 ) {

                        extensions.get( 'EXT_color_buffer_float' );

                }

                return internalFormat;

        }

        // Fallback filters for non-power-of-2 textures

        function filterFallback( f ) {

                if ( f === NearestFilter || f === NearestMipmapNearestFilter || f === NearestMipmapLinearFilter ) {

                        return 9728;

                }

                return 9729;

        }

        //

        function onTextureDispose( event ) {

                const texture = event.target;

                texture.removeEventListener( 'dispose', onTextureDispose );

                deallocateTexture( texture );

                if ( texture.isVideoTexture ) {

                        _videoTextures.delete( texture );

                }

                info.memory.textures --;

        }

        function onRenderTargetDispose( event ) {

                const renderTarget = event.target;

                renderTarget.removeEventListener( 'dispose', onRenderTargetDispose );

                deallocateRenderTarget( renderTarget );

                info.memory.textures --;

        }

        //

        function deallocateTexture( texture ) {

                const textureProperties = properties.get( texture );

                if ( textureProperties.__webglInit === undefined ) return;

                _gl.deleteTexture( textureProperties.__webglTexture );

                properties.remove( texture );

        }

        function deallocateRenderTarget( renderTarget ) {

                const renderTargetProperties = properties.get( renderTarget );
                const textureProperties = properties.get( renderTarget.texture );

                if ( ! renderTarget ) return;

                if ( textureProperties.__webglTexture !== undefined ) {

                        _gl.deleteTexture( textureProperties.__webglTexture );

                }

                if ( renderTarget.depthTexture ) {

                        renderTarget.depthTexture.dispose();

                }

                if ( renderTarget.isWebGLCubeRenderTarget ) {

                        for ( let i = 0; i < 6; i ++ ) {

                                _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );
                                if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );

                        }

                } else {

                        _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );
                        if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );
                        if ( renderTargetProperties.__webglMultisampledFramebuffer ) _gl.deleteFramebuffer( renderTargetProperties.__webglMultisampledFramebuffer );
                        if ( renderTargetProperties.__webglColorRenderbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglColorRenderbuffer );
                        if ( renderTargetProperties.__webglDepthRenderbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthRenderbuffer );

                }

                properties.remove( renderTarget.texture );
                properties.remove( renderTarget );

        }

        //

        let textureUnits = 0;

        function resetTextureUnits() {

                textureUnits = 0;

        }

        function allocateTextureUnit() {

                const textureUnit = textureUnits;

                if ( textureUnit >= maxTextures ) {

                        console.warn( 'THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + maxTextures );

                }

                textureUnits += 1;

                return textureUnit;

        }

        //

        function setTexture2D( texture, slot ) {

                const textureProperties = properties.get( texture );

                if ( texture.isVideoTexture ) updateVideoTexture( texture );

                if ( texture.version > 0 && textureProperties.__version !== texture.version ) {

                        const image = texture.image;

                        if ( image === undefined ) {

                                console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is undefined' );

                        } else if ( image.complete === false ) {

                                console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete' );

                        } else {

                                uploadTexture( textureProperties, texture, slot );
                                return;

                        }

                }

                state.activeTexture( 33984 + slot );
                state.bindTexture( 3553, textureProperties.__webglTexture );

        }

        function setTexture2DArray( texture, slot ) {

                const textureProperties = properties.get( texture );

                if ( texture.version > 0 && textureProperties.__version !== texture.version ) {

                        uploadTexture( textureProperties, texture, slot );
                        return;

                }

                state.activeTexture( 33984 + slot );
                state.bindTexture( 35866, textureProperties.__webglTexture );

        }

        function setTexture3D( texture, slot ) {

                const textureProperties = properties.get( texture );

                if ( texture.version > 0 && textureProperties.__version !== texture.version ) {

                        uploadTexture( textureProperties, texture, slot );
                        return;

                }

                state.activeTexture( 33984 + slot );
                state.bindTexture( 32879, textureProperties.__webglTexture );

        }

        function setTextureCube( texture, slot ) {

                const textureProperties = properties.get( texture );

                if ( texture.version > 0 && textureProperties.__version !== texture.version ) {

                        uploadCubeTexture( textureProperties, texture, slot );
                        return;

                }

                state.activeTexture( 33984 + slot );
                state.bindTexture( 34067, textureProperties.__webglTexture );

        }

        const wrappingToGL = {
                [ RepeatWrapping ]: 10497,
                [ ClampToEdgeWrapping ]: 33071,
                [ MirroredRepeatWrapping ]: 33648
        };

        const filterToGL = {
                [ NearestFilter ]: 9728,
                [ NearestMipmapNearestFilter ]: 9984,
                [ NearestMipmapLinearFilter ]: 9986,

                [ LinearFilter ]: 9729,
                [ LinearMipmapNearestFilter ]: 9985,
                [ LinearMipmapLinearFilter ]: 9987
        };

        function setTextureParameters( textureType, texture, supportsMips ) {

                if ( supportsMips ) {

                        _gl.texParameteri( textureType, 10242, wrappingToGL[ texture.wrapS ] );
                        _gl.texParameteri( textureType, 10243, wrappingToGL[ texture.wrapT ] );

                        if ( textureType === 32879 || textureType === 35866 ) {

                                _gl.texParameteri( textureType, 32882, wrappingToGL[ texture.wrapR ] );

                        }

                        _gl.texParameteri( textureType, 10240, filterToGL[ texture.magFilter ] );
                        _gl.texParameteri( textureType, 10241, filterToGL[ texture.minFilter ] );

                } else {

                        _gl.texParameteri( textureType, 10242, 33071 );
                        _gl.texParameteri( textureType, 10243, 33071 );

                        if ( textureType === 32879 || textureType === 35866 ) {

                                _gl.texParameteri( textureType, 32882, 33071 );

                        }

                        if ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) {

                                console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.' );

                        }

                        _gl.texParameteri( textureType, 10240, filterFallback( texture.magFilter ) );
                        _gl.texParameteri( textureType, 10241, filterFallback( texture.minFilter ) );

                        if ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) {

                                console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.' );

                        }

                }

                const extension = extensions.get( 'EXT_texture_filter_anisotropic' );

                if ( extension ) {

                        if ( texture.type === FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return;
                        if ( texture.type === HalfFloatType && ( isWebGL2 || extensions.get( 'OES_texture_half_float_linear' ) ) === null ) return;

                        if ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {

                                _gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) );
                                properties.get( texture ).__currentAnisotropy = texture.anisotropy;

                        }

                }

        }

        function initTexture( textureProperties, texture ) {

                if ( textureProperties.__webglInit === undefined ) {

                        textureProperties.__webglInit = true;

                        texture.addEventListener( 'dispose', onTextureDispose );

                        textureProperties.__webglTexture = _gl.createTexture();

                        info.memory.textures ++;

                }

        }

        function uploadTexture( textureProperties, texture, slot ) {

                let textureType = 3553;

                if ( texture.isDataTexture2DArray ) textureType = 35866;
                if ( texture.isDataTexture3D ) textureType = 32879;

                initTexture( textureProperties, texture );

                state.activeTexture( 33984 + slot );
                state.bindTexture( textureType, textureProperties.__webglTexture );

                _gl.pixelStorei( 37440, texture.flipY );
                _gl.pixelStorei( 37441, texture.premultiplyAlpha );
                _gl.pixelStorei( 3317, texture.unpackAlignment );

                const needsPowerOfTwo = textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( texture.image ) === false;
                const image = resizeImage( texture.image, needsPowerOfTwo, false, maxTextureSize );

                const supportsMips = isPowerOfTwo( image ) || isWebGL2,
                        glFormat = utils.convert( texture.format );

                let glType = utils.convert( texture.type ),
                        glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType );

                setTextureParameters( textureType, texture, supportsMips );

                let mipmap;
                const mipmaps = texture.mipmaps;

                if ( texture.isDepthTexture ) {

                        // populate depth texture with dummy data

                        glInternalFormat = 6402;

                        if ( isWebGL2 ) {

                                if ( texture.type === FloatType ) {

                                        glInternalFormat = 36012;

                                } else if ( texture.type === UnsignedIntType ) {

                                        glInternalFormat = 33190;

                                } else if ( texture.type === UnsignedInt248Type ) {

                                        glInternalFormat = 35056;

                                } else {

                                        glInternalFormat = 33189; // WebGL2 requires sized internalformat for glTexImage2D

                                }

                        } else {

                                if ( texture.type === FloatType ) {

                                        console.error( 'WebGLRenderer: Floating point depth texture requires WebGL2.' );

                                }

                        }

                        // validation checks for WebGL 1

                        if ( texture.format === DepthFormat && glInternalFormat === 6402 ) {

                                // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
                                // DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT
                                // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
                                if ( texture.type !== UnsignedShortType && texture.type !== UnsignedIntType ) {

                                        console.warn( 'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.' );

                                        texture.type = UnsignedShortType;
                                        glType = utils.convert( texture.type );

                                }

                        }

                        if ( texture.format === DepthStencilFormat && glInternalFormat === 6402 ) {

                                // Depth stencil textures need the DEPTH_STENCIL internal format
                                // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
                                glInternalFormat = 34041;

                                // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
                                // DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.
                                // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
                                if ( texture.type !== UnsignedInt248Type ) {

                                        console.warn( 'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.' );

                                        texture.type = UnsignedInt248Type;
                                        glType = utils.convert( texture.type );

                                }

                        }

                        //

                        state.texImage2D( 3553, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null );

                } else if ( texture.isDataTexture ) {

                        // use manually created mipmaps if available
                        // if there are no manual mipmaps
                        // set 0 level mipmap and then use GL to generate other mipmap levels

                        if ( mipmaps.length > 0 && supportsMips ) {

                                for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {

                                        mipmap = mipmaps[ i ];
                                        state.texImage2D( 3553, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );

                                }

                                texture.generateMipmaps = false;
                                textureProperties.__maxMipLevel = mipmaps.length - 1;

                        } else {

                                state.texImage2D( 3553, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data );
                                textureProperties.__maxMipLevel = 0;

                        }

                } else if ( texture.isCompressedTexture ) {

                        for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {

                                mipmap = mipmaps[ i ];

                                if ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) {

                                        if ( glFormat !== null ) {

                                                state.compressedTexImage2D( 3553, i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );

                                        } else {

                                                console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );

                                        }

                                } else {

                                        state.texImage2D( 3553, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );

                                }

                        }

                        textureProperties.__maxMipLevel = mipmaps.length - 1;

                } else if ( texture.isDataTexture2DArray ) {

                        state.texImage3D( 35866, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data );
                        textureProperties.__maxMipLevel = 0;

                } else if ( texture.isDataTexture3D ) {

                        state.texImage3D( 32879, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data );
                        textureProperties.__maxMipLevel = 0;

                } else {

                        // regular Texture (image, video, canvas)

                        // use manually created mipmaps if available
                        // if there are no manual mipmaps
                        // set 0 level mipmap and then use GL to generate other mipmap levels

                        if ( mipmaps.length > 0 && supportsMips ) {

                                for ( let i = 0, il = mipmaps.length; i < il; i ++ ) {

                                        mipmap = mipmaps[ i ];
                                        state.texImage2D( 3553, i, glInternalFormat, glFormat, glType, mipmap );

                                }

                                texture.generateMipmaps = false;
                                textureProperties.__maxMipLevel = mipmaps.length - 1;

                        } else {

                                state.texImage2D( 3553, 0, glInternalFormat, glFormat, glType, image );
                                textureProperties.__maxMipLevel = 0;

                        }

                }

                if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {

                        generateMipmap( textureType, texture, image.width, image.height );

                }

                textureProperties.__version = texture.version;

                if ( texture.onUpdate ) texture.onUpdate( texture );

        }

        function uploadCubeTexture( textureProperties, texture, slot ) {

                if ( texture.image.length !== 6 ) return;

                initTexture( textureProperties, texture );

                state.activeTexture( 33984 + slot );
                state.bindTexture( 34067, textureProperties.__webglTexture );

                _gl.pixelStorei( 37440, texture.flipY );
                _gl.pixelStorei( 37441, texture.premultiplyAlpha );
                _gl.pixelStorei( 3317, texture.unpackAlignment );

                const isCompressed = ( texture && ( texture.isCompressedTexture || texture.image[ 0 ].isCompressedTexture ) );
                const isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture );

                const cubeImage = [];

                for ( let i = 0; i < 6; i ++ ) {

                        if ( ! isCompressed && ! isDataTexture ) {

                                cubeImage[ i ] = resizeImage( texture.image[ i ], false, true, maxCubemapSize );

                        } else {

                                cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];

                        }

                }

                const image = cubeImage[ 0 ],
                        supportsMips = isPowerOfTwo( image ) || isWebGL2,
                        glFormat = utils.convert( texture.format ),
                        glType = utils.convert( texture.type ),
                        glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType );

                setTextureParameters( 34067, texture, supportsMips );

                let mipmaps;

                if ( isCompressed ) {

                        for ( let i = 0; i < 6; i ++ ) {

                                mipmaps = cubeImage[ i ].mipmaps;

                                for ( let j = 0; j < mipmaps.length; j ++ ) {

                                        const mipmap = mipmaps[ j ];

                                        if ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) {

                                                if ( glFormat !== null ) {

                                                        state.compressedTexImage2D( 34069 + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );

                                                } else {

                                                        console.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()' );

                                                }

                                        } else {

                                                state.texImage2D( 34069 + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );

                                        }

                                }

                        }

                        textureProperties.__maxMipLevel = mipmaps.length - 1;

                } else {

                        mipmaps = texture.mipmaps;

                        for ( let i = 0; i < 6; i ++ ) {

                                if ( isDataTexture ) {

                                        state.texImage2D( 34069 + i, 0, glInternalFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );

                                        for ( let j = 0; j < mipmaps.length; j ++ ) {

                                                const mipmap = mipmaps[ j ];
                                                const mipmapImage = mipmap.image[ i ].image;

                                                state.texImage2D( 34069 + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data );

                                        }

                                } else {

                                        state.texImage2D( 34069 + i, 0, glInternalFormat, glFormat, glType, cubeImage[ i ] );

                                        for ( let j = 0; j < mipmaps.length; j ++ ) {

                                                const mipmap = mipmaps[ j ];

                                                state.texImage2D( 34069 + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[ i ] );

                                        }

                                }

                        }

                        textureProperties.__maxMipLevel = mipmaps.length;

                }

                if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {

                        // We assume images for cube map have the same size.
                        generateMipmap( 34067, texture, image.width, image.height );

                }

                textureProperties.__version = texture.version;

                if ( texture.onUpdate ) texture.onUpdate( texture );

        }

        // Render targets

        // Setup storage for target texture and bind it to correct framebuffer
        function setupFrameBufferTexture( framebuffer, renderTarget, attachment, textureTarget ) {

                const glFormat = utils.convert( renderTarget.texture.format );
                const glType = utils.convert( renderTarget.texture.type );
                const glInternalFormat = getInternalFormat( renderTarget.texture.internalFormat, glFormat, glType );
                state.texImage2D( textureTarget, 0, glInternalFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null );
                _gl.bindFramebuffer( 36160, framebuffer );
                _gl.framebufferTexture2D( 36160, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 );
                _gl.bindFramebuffer( 36160, null );

        }

        // Setup storage for internal depth/stencil buffers and bind to correct framebuffer
        function setupRenderBufferStorage( renderbuffer, renderTarget, isMultisample ) {

                _gl.bindRenderbuffer( 36161, renderbuffer );

                if ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {

                        let glInternalFormat = 33189;

                        if ( isMultisample ) {

                                const depthTexture = renderTarget.depthTexture;

                                if ( depthTexture && depthTexture.isDepthTexture ) {

                                        if ( depthTexture.type === FloatType ) {

                                                glInternalFormat = 36012;

                                        } else if ( depthTexture.type === UnsignedIntType ) {

                                                glInternalFormat = 33190;

                                        }

                                }

                                const samples = getRenderTargetSamples( renderTarget );

                                _gl.renderbufferStorageMultisample( 36161, samples, glInternalFormat, renderTarget.width, renderTarget.height );

                        } else {

                                _gl.renderbufferStorage( 36161, glInternalFormat, renderTarget.width, renderTarget.height );

                        }

                        _gl.framebufferRenderbuffer( 36160, 36096, 36161, renderbuffer );

                } else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {

                        if ( isMultisample ) {

                                const samples = getRenderTargetSamples( renderTarget );

                                _gl.renderbufferStorageMultisample( 36161, samples, 35056, renderTarget.width, renderTarget.height );

                        } else {

                                _gl.renderbufferStorage( 36161, 34041, renderTarget.width, renderTarget.height );

                        }


                        _gl.framebufferRenderbuffer( 36160, 33306, 36161, renderbuffer );

                } else {

                        const glFormat = utils.convert( renderTarget.texture.format );
                        const glType = utils.convert( renderTarget.texture.type );
                        const glInternalFormat = getInternalFormat( renderTarget.texture.internalFormat, glFormat, glType );

                        if ( isMultisample ) {

                                const samples = getRenderTargetSamples( renderTarget );

                                _gl.renderbufferStorageMultisample( 36161, samples, glInternalFormat, renderTarget.width, renderTarget.height );

                        } else {

                                _gl.renderbufferStorage( 36161, glInternalFormat, renderTarget.width, renderTarget.height );

                        }

                }

                _gl.bindRenderbuffer( 36161, null );

        }

        // Setup resources for a Depth Texture for a FBO (needs an extension)
        function setupDepthTexture( framebuffer, renderTarget ) {

                const isCube = ( renderTarget && renderTarget.isWebGLCubeRenderTarget );
                if ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' );

                _gl.bindFramebuffer( 36160, framebuffer );

                if ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) {

                        throw new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' );

                }

                // upload an empty depth texture with framebuffer size
                if ( ! properties.get( renderTarget.depthTexture ).__webglTexture ||
                                renderTarget.depthTexture.image.width !== renderTarget.width ||
                                renderTarget.depthTexture.image.height !== renderTarget.height ) {

                        renderTarget.depthTexture.image.width = renderTarget.width;
                        renderTarget.depthTexture.image.height = renderTarget.height;
                        renderTarget.depthTexture.needsUpdate = true;

                }

                setTexture2D( renderTarget.depthTexture, 0 );

                const webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;

                if ( renderTarget.depthTexture.format === DepthFormat ) {

                        _gl.framebufferTexture2D( 36160, 36096, 3553, webglDepthTexture, 0 );

                } else if ( renderTarget.depthTexture.format === DepthStencilFormat ) {

                        _gl.framebufferTexture2D( 36160, 33306, 3553, webglDepthTexture, 0 );

                } else {

                        throw new Error( 'Unknown depthTexture format' );

                }

        }

        // Setup GL resources for a non-texture depth buffer
        function setupDepthRenderbuffer( renderTarget ) {

                const renderTargetProperties = properties.get( renderTarget );

                const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );

                if ( renderTarget.depthTexture ) {

                        if ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );

                        setupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );

                } else {

                        if ( isCube ) {

                                renderTargetProperties.__webglDepthbuffer = [];

                                for ( let i = 0; i < 6; i ++ ) {

                                        _gl.bindFramebuffer( 36160, renderTargetProperties.__webglFramebuffer[ i ] );
                                        renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
                                        setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget, false );

                                }

                        } else {

                                _gl.bindFramebuffer( 36160, renderTargetProperties.__webglFramebuffer );
                                renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
                                setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );

                        }

                }

                _gl.bindFramebuffer( 36160, null );

        }

        // Set up GL resources for the render target
        function setupRenderTarget( renderTarget ) {

                const renderTargetProperties = properties.get( renderTarget );
                const textureProperties = properties.get( renderTarget.texture );

                renderTarget.addEventListener( 'dispose', onRenderTargetDispose );

                textureProperties.__webglTexture = _gl.createTexture();

                info.memory.textures ++;

                const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );
                const isMultisample = ( renderTarget.isWebGLMultisampleRenderTarget === true );
                const supportsMips = isPowerOfTwo( renderTarget ) || isWebGL2;

                // Handles WebGL2 RGBFormat fallback - #18858

                if ( isWebGL2 && renderTarget.texture.format === RGBFormat && ( renderTarget.texture.type === FloatType || renderTarget.texture.type === HalfFloatType ) ) {

                        renderTarget.texture.format = RGBAFormat;

                        console.warn( 'THREE.WebGLRenderer: Rendering to textures with RGB format is not supported. Using RGBA format instead.' );

                }

                // Setup framebuffer

                if ( isCube ) {

                        renderTargetProperties.__webglFramebuffer = [];

                        for ( let i = 0; i < 6; i ++ ) {

                                renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();

                        }

                } else {

                        renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();

                        if ( isMultisample ) {

                                if ( isWebGL2 ) {

                                        renderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer();
                                        renderTargetProperties.__webglColorRenderbuffer = _gl.createRenderbuffer();

                                        _gl.bindRenderbuffer( 36161, renderTargetProperties.__webglColorRenderbuffer );

                                        const glFormat = utils.convert( renderTarget.texture.format );
                                        const glType = utils.convert( renderTarget.texture.type );
                                        const glInternalFormat = getInternalFormat( renderTarget.texture.internalFormat, glFormat, glType );
                                        const samples = getRenderTargetSamples( renderTarget );
                                        _gl.renderbufferStorageMultisample( 36161, samples, glInternalFormat, renderTarget.width, renderTarget.height );

                                        _gl.bindFramebuffer( 36160, renderTargetProperties.__webglMultisampledFramebuffer );
                                        _gl.framebufferRenderbuffer( 36160, 36064, 36161, renderTargetProperties.__webglColorRenderbuffer );
                                        _gl.bindRenderbuffer( 36161, null );

                                        if ( renderTarget.depthBuffer ) {

                                                renderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer();
                                                setupRenderBufferStorage( renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true );

                                        }

                                        _gl.bindFramebuffer( 36160, null );


                                } else {

                                        console.warn( 'THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.' );

                                }

                        }

                }

                // Setup color buffer

                if ( isCube ) {

                        state.bindTexture( 34067, textureProperties.__webglTexture );
                        setTextureParameters( 34067, renderTarget.texture, supportsMips );

                        for ( let i = 0; i < 6; i ++ ) {

                                setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, 36064, 34069 + i );

                        }

                        if ( textureNeedsGenerateMipmaps( renderTarget.texture, supportsMips ) ) {

                                generateMipmap( 34067, renderTarget.texture, renderTarget.width, renderTarget.height );

                        }

                        state.bindTexture( 34067, null );

                } else {

                        state.bindTexture( 3553, textureProperties.__webglTexture );
                        setTextureParameters( 3553, renderTarget.texture, supportsMips );
                        setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, 36064, 3553 );

                        if ( textureNeedsGenerateMipmaps( renderTarget.texture, supportsMips ) ) {

                                generateMipmap( 3553, renderTarget.texture, renderTarget.width, renderTarget.height );

                        }

                        state.bindTexture( 3553, null );

                }

                // Setup depth and stencil buffers

                if ( renderTarget.depthBuffer ) {

                        setupDepthRenderbuffer( renderTarget );

                }

        }

        function updateRenderTargetMipmap( renderTarget ) {

                const texture = renderTarget.texture;
                const supportsMips = isPowerOfTwo( renderTarget ) || isWebGL2;

                if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {

                        const target = renderTarget.isWebGLCubeRenderTarget ? 34067 : 3553;
                        const webglTexture = properties.get( texture ).__webglTexture;

                        state.bindTexture( target, webglTexture );
                        generateMipmap( target, texture, renderTarget.width, renderTarget.height );
                        state.bindTexture( target, null );

                }

        }

        function updateMultisampleRenderTarget( renderTarget ) {

                if ( renderTarget.isWebGLMultisampleRenderTarget ) {

                        if ( isWebGL2 ) {

                                const renderTargetProperties = properties.get( renderTarget );

                                _gl.bindFramebuffer( 36008, renderTargetProperties.__webglMultisampledFramebuffer );
                                _gl.bindFramebuffer( 36009, renderTargetProperties.__webglFramebuffer );

                                const width = renderTarget.width;
                                const height = renderTarget.height;
                                let mask = 16384;

                                if ( renderTarget.depthBuffer ) mask |= 256;
                                if ( renderTarget.stencilBuffer ) mask |= 1024;

                                _gl.blitFramebuffer( 0, 0, width, height, 0, 0, width, height, mask, 9728 );

                                _gl.bindFramebuffer( 36160, renderTargetProperties.__webglMultisampledFramebuffer ); // see #18905

                        } else {

                                console.warn( 'THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.' );

                        }

                }

        }

        function getRenderTargetSamples( renderTarget ) {

                return ( isWebGL2 && renderTarget.isWebGLMultisampleRenderTarget ) ?
                        Math.min( maxSamples, renderTarget.samples ) : 0;

        }

        function updateVideoTexture( texture ) {

                const frame = info.render.frame;

                // Check the last frame we updated the VideoTexture

                if ( _videoTextures.get( texture ) !== frame ) {

                        _videoTextures.set( texture, frame );
                        texture.update();

                }

        }

        // backwards compatibility

        let warnedTexture2D = false;
        let warnedTextureCube = false;

        function safeSetTexture2D( texture, slot ) {

                if ( texture && texture.isWebGLRenderTarget ) {

                        if ( warnedTexture2D === false ) {

                                console.warn( 'THREE.WebGLTextures.safeSetTexture2D: don\'t use render targets as textures. Use their .texture property instead.' );
                                warnedTexture2D = true;

                        }

                        texture = texture.texture;

                }

                setTexture2D( texture, slot );

        }

        function safeSetTextureCube( texture, slot ) {

                if ( texture && texture.isWebGLCubeRenderTarget ) {

                        if ( warnedTextureCube === false ) {

                                console.warn( 'THREE.WebGLTextures.safeSetTextureCube: don\'t use cube render targets as textures. Use their .texture property instead.' );
                                warnedTextureCube = true;

                        }

                        texture = texture.texture;

                }


                setTextureCube( texture, slot );

        }

        //

        this.allocateTextureUnit = allocateTextureUnit;
        this.resetTextureUnits = resetTextureUnits;

        this.setTexture2D = setTexture2D;
        this.setTexture2DArray = setTexture2DArray;
        this.setTexture3D = setTexture3D;
        this.setTextureCube = setTextureCube;
        this.setupRenderTarget = setupRenderTarget;
        this.updateRenderTargetMipmap = updateRenderTargetMipmap;
        this.updateMultisampleRenderTarget = updateMultisampleRenderTarget;

        this.safeSetTexture2D = safeSetTexture2D;
        this.safeSetTextureCube = safeSetTextureCube;

    }

    function WebGLUtils( gl, extensions, capabilities ) {

        const isWebGL2 = capabilities.isWebGL2;

        function convert( p ) {

                let extension;

                if ( p === UnsignedByteType ) return 5121;
                if ( p === UnsignedShort4444Type ) return 32819;
                if ( p === UnsignedShort5551Type ) return 32820;
                if ( p === UnsignedShort565Type ) return 33635;

                if ( p === ByteType ) return 5120;
                if ( p === ShortType ) return 5122;
                if ( p === UnsignedShortType ) return 5123;
                if ( p === IntType ) return 5124;
                if ( p === UnsignedIntType ) return 5125;
                if ( p === FloatType ) return 5126;

                if ( p === HalfFloatType ) {

                        if ( isWebGL2 ) return 5131;

                        extension = extensions.get( 'OES_texture_half_float' );

                        if ( extension !== null ) {

                                return extension.HALF_FLOAT_OES;

                        } else {

                                return null;

                        }

                }

                if ( p === AlphaFormat ) return 6406;
                if ( p === RGBFormat ) return 6407;
                if ( p === RGBAFormat ) return 6408;
                if ( p === LuminanceFormat ) return 6409;
                if ( p === LuminanceAlphaFormat ) return 6410;
                if ( p === DepthFormat ) return 6402;
                if ( p === DepthStencilFormat ) return 34041;
                if ( p === RedFormat ) return 6403;

                // WebGL2 formats.

                if ( p === RedIntegerFormat ) return 36244;
                if ( p === RGFormat ) return 33319;
                if ( p === RGIntegerFormat ) return 33320;
                if ( p === RGBIntegerFormat ) return 36248;
                if ( p === RGBAIntegerFormat ) return 36249;

                if ( p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format ||
                        p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format ) {

                        extension = extensions.get( 'WEBGL_compressed_texture_s3tc' );

                        if ( extension !== null ) {

                                if ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
                                if ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
                                if ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
                                if ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;

                        } else {

                                return null;

                        }

                }

                if ( p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format ||
                        p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format ) {

                        extension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );

                        if ( extension !== null ) {

                                if ( p === RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
                                if ( p === RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
                                if ( p === RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
                                if ( p === RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;

                        } else {

                                return null;

                        }

                }

                if ( p === RGB_ETC1_Format ) {

                        extension = extensions.get( 'WEBGL_compressed_texture_etc1' );

                        if ( extension !== null ) {

                                return extension.COMPRESSED_RGB_ETC1_WEBGL;

                        } else {

                                return null;

                        }

                }

                if ( p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format ) {

                        extension = extensions.get( 'WEBGL_compressed_texture_etc' );

                        if ( extension !== null ) {

                                if ( p === RGB_ETC2_Format ) return extension.COMPRESSED_RGB8_ETC2;
                                if ( p === RGBA_ETC2_EAC_Format ) return extension.COMPRESSED_RGBA8_ETC2_EAC;

                        }

                }

                if ( p === RGBA_ASTC_4x4_Format || p === RGBA_ASTC_5x4_Format || p === RGBA_ASTC_5x5_Format ||
                        p === RGBA_ASTC_6x5_Format || p === RGBA_ASTC_6x6_Format || p === RGBA_ASTC_8x5_Format ||
                        p === RGBA_ASTC_8x6_Format || p === RGBA_ASTC_8x8_Format || p === RGBA_ASTC_10x5_Format ||
                        p === RGBA_ASTC_10x6_Format || p === RGBA_ASTC_10x8_Format || p === RGBA_ASTC_10x10_Format ||
                        p === RGBA_ASTC_12x10_Format || p === RGBA_ASTC_12x12_Format ||
                        p === SRGB8_ALPHA8_ASTC_4x4_Format || p === SRGB8_ALPHA8_ASTC_5x4_Format || p === SRGB8_ALPHA8_ASTC_5x5_Format ||
                        p === SRGB8_ALPHA8_ASTC_6x5_Format || p === SRGB8_ALPHA8_ASTC_6x6_Format || p === SRGB8_ALPHA8_ASTC_8x5_Format ||
                        p === SRGB8_ALPHA8_ASTC_8x6_Format || p === SRGB8_ALPHA8_ASTC_8x8_Format || p === SRGB8_ALPHA8_ASTC_10x5_Format ||
                        p === SRGB8_ALPHA8_ASTC_10x6_Format || p === SRGB8_ALPHA8_ASTC_10x8_Format || p === SRGB8_ALPHA8_ASTC_10x10_Format ||
                        p === SRGB8_ALPHA8_ASTC_12x10_Format || p === SRGB8_ALPHA8_ASTC_12x12_Format ) {

                        extension = extensions.get( 'WEBGL_compressed_texture_astc' );

                        if ( extension !== null ) {

                                // TODO Complete?

                                return p;

                        } else {

                                return null;

                        }

                }

                if ( p === RGBA_BPTC_Format ) {

                        extension = extensions.get( 'EXT_texture_compression_bptc' );

                        if ( extension !== null ) {

                                // TODO Complete?

                                return p;

                        } else {

                                return null;

                        }

                }

                if ( p === UnsignedInt248Type ) {

                        if ( isWebGL2 ) return 34042;

                        extension = extensions.get( 'WEBGL_depth_texture' );

                        if ( extension !== null ) {

                                return extension.UNSIGNED_INT_24_8_WEBGL;

                        } else {

                                return null;

                        }

                }

        }

        return { convert: convert };

    }

    function ArrayCamera( array = [] ) {

        PerspectiveCamera.call( this );

        this.cameras = array;

    }

    ArrayCamera.prototype = Object.assign( Object.create( PerspectiveCamera.prototype ), {

        constructor: ArrayCamera,

        isArrayCamera: true

    } );

    function Group() {

        Object3D.call( this );

        this.type = 'Group';

    }

    Group.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Group,

        isGroup: true

    } );

    function WebXRController() {

        this._targetRay = null;
        this._grip = null;
        this._hand = null;

    }

    Object.assign( WebXRController.prototype, {

        constructor: WebXRController,

        getHandSpace: function () {

                if ( this._hand === null ) {

                        this._hand = new Group();
                        this._hand.matrixAutoUpdate = false;
                        this._hand.visible = false;

                        this._hand.joints = {};
                        this._hand.inputState = { pinching: false };

                }

                return this._hand;

        },

        getTargetRaySpace: function () {

                if ( this._targetRay === null ) {

                        this._targetRay = new Group();
                        this._targetRay.matrixAutoUpdate = false;
                        this._targetRay.visible = false;

                }

                return this._targetRay;

        },

        getGripSpace: function () {

                if ( this._grip === null ) {

                        this._grip = new Group();
                        this._grip.matrixAutoUpdate = false;
                        this._grip.visible = false;

                }

                return this._grip;

        },

        dispatchEvent: function ( event ) {

                if ( this._targetRay !== null ) {

                        this._targetRay.dispatchEvent( event );

                }

                if ( this._grip !== null ) {

                        this._grip.dispatchEvent( event );

                }

                if ( this._hand !== null ) {

                        this._hand.dispatchEvent( event );

                }

                return this;

        },

        disconnect: function ( inputSource ) {

                this.dispatchEvent( { type: 'disconnected', data: inputSource } );

                if ( this._targetRay !== null ) {

                        this._targetRay.visible = false;

                }

                if ( this._grip !== null ) {

                        this._grip.visible = false;

                }

                if ( this._hand !== null ) {

                        this._hand.visible = false;

                }

                return this;

        },

        update: function ( inputSource, frame, referenceSpace ) {

                let inputPose = null;
                let gripPose = null;
                let handPose = null;

                const targetRay = this._targetRay;
                const grip = this._grip;
                const hand = this._hand;

                if ( inputSource && frame.session.visibilityState !== 'visible-blurred' ) {

                        if ( hand && inputSource.hand ) {

                                handPose = true;

                                for ( const inputjoint of inputSource.hand.values() ) {

                                        // Update the joints groups with the XRJoint poses
                                        const jointPose = frame.getJointPose( inputjoint, referenceSpace );

                                        if ( hand.joints[ inputjoint.jointName ] === undefined ) {

                                                // The transform of this joint will be updated with the joint pose on each frame
                                                const joint = new Group();
                                                joint.matrixAutoUpdate = false;
                                                joint.visible = false;
                                                hand.joints[ inputjoint.jointName ] = joint;
                                                // ??
                                                hand.add( joint );

                                        }

                                        const joint = hand.joints[ inputjoint.jointName ];

                                        if ( jointPose !== null ) {

                                                joint.matrix.fromArray( jointPose.transform.matrix );
                                                joint.matrix.decompose( joint.position, joint.rotation, joint.scale );
                                                joint.jointRadius = jointPose.radius;

                                        }

                                        joint.visible = jointPose !== null;

                                }

                                // Custom events

                                // Check pinchz
                                const indexTip = hand.joints[ 'index-finger-tip' ];
                                const thumbTip = hand.joints[ 'thumb-tip' ];
                                const distance = indexTip.position.distanceTo( thumbTip.position );

                                const distanceToPinch = 0.02;
                                const threshold = 0.005;

                                if ( hand.inputState.pinching && distance > distanceToPinch + threshold ) {

                                        hand.inputState.pinching = false;
                                        this.dispatchEvent( {
                                                type: 'pinchend',
                                                handedness: inputSource.handedness,
                                                target: this
                                        } );

                                } else if ( ! hand.inputState.pinching && distance <= distanceToPinch - threshold ) {

                                        hand.inputState.pinching = true;
                                        this.dispatchEvent( {
                                                type: 'pinchstart',
                                                handedness: inputSource.handedness,
                                                target: this
                                        } );

                                }

                        } else {

                                if ( targetRay !== null ) {

                                        inputPose = frame.getPose( inputSource.targetRaySpace, referenceSpace );

                                        if ( inputPose !== null ) {

                                                targetRay.matrix.fromArray( inputPose.transform.matrix );
                                                targetRay.matrix.decompose( targetRay.position, targetRay.rotation, targetRay.scale );

                                        }

                                }

                                if ( grip !== null && inputSource.gripSpace ) {

                                        gripPose = frame.getPose( inputSource.gripSpace, referenceSpace );

                                        if ( gripPose !== null ) {

                                                grip.matrix.fromArray( gripPose.transform.matrix );
                                                grip.matrix.decompose( grip.position, grip.rotation, grip.scale );

                                        }

                                }

                        }

                }

                if ( targetRay !== null ) {

                        targetRay.visible = ( inputPose !== null );

                }

                if ( grip !== null ) {

                        grip.visible = ( gripPose !== null );

                }

                if ( hand !== null ) {

                        hand.visible = ( handPose !== null );

                }

                return this;

        }

    } );

    function WebXRManager( renderer, gl ) {

        const scope = this;

        let session = null;

        let framebufferScaleFactor = 1.0;

        let referenceSpace = null;
        let referenceSpaceType = 'local-floor';

        let pose = null;

        const controllers = [];
        const inputSourcesMap = new Map();

        //

        const cameraL = new PerspectiveCamera();
        cameraL.layers.enable( 1 );
        cameraL.viewport = new Vector4();

        const cameraR = new PerspectiveCamera();
        cameraR.layers.enable( 2 );
        cameraR.viewport = new Vector4();

        const cameras = [ cameraL, cameraR ];

        const cameraVR = new ArrayCamera();
        cameraVR.layers.enable( 1 );
        cameraVR.layers.enable( 2 );

        let _currentDepthNear = null;
        let _currentDepthFar = null;

        //

        this.enabled = false;

        this.isPresenting = false;

        this.getController = function ( index ) {

                let controller = controllers[ index ];

                if ( controller === undefined ) {

                        controller = new WebXRController();
                        controllers[ index ] = controller;

                }

                return controller.getTargetRaySpace();

        };

        this.getControllerGrip = function ( index ) {

                let controller = controllers[ index ];

                if ( controller === undefined ) {

                        controller = new WebXRController();
                        controllers[ index ] = controller;

                }

                return controller.getGripSpace();

        };

        this.getHand = function ( index ) {

                let controller = controllers[ index ];

                if ( controller === undefined ) {

                        controller = new WebXRController();
                        controllers[ index ] = controller;

                }

                return controller.getHandSpace();

        };

        //

        function onSessionEvent( event ) {

                const controller = inputSourcesMap.get( event.inputSource );

                if ( controller ) {

                        controller.dispatchEvent( { type: event.type, data: event.inputSource } );

                }

        }

        function onSessionEnd() {

                inputSourcesMap.forEach( function ( controller, inputSource ) {

                        controller.disconnect( inputSource );

                } );

                inputSourcesMap.clear();

                _currentDepthNear = null;
                _currentDepthFar = null;

                //

                renderer.setFramebuffer( null );
                renderer.setRenderTarget( renderer.getRenderTarget() ); // Hack #15830
                animation.stop();

                scope.isPresenting = false;

                scope.dispatchEvent( { type: 'sessionend' } );

        }

        this.setFramebufferScaleFactor = function ( value ) {

                framebufferScaleFactor = value;

                if ( scope.isPresenting === true ) {

                        console.warn( 'THREE.WebXRManager: Cannot change framebuffer scale while presenting.' );

                }

        };

        this.setReferenceSpaceType = function ( value ) {

                referenceSpaceType = value;

                if ( scope.isPresenting === true ) {

                        console.warn( 'THREE.WebXRManager: Cannot change reference space type while presenting.' );

                }

        };

        this.getReferenceSpace = function () {

                return referenceSpace;

        };

        this.getSession = function () {

                return session;

        };

        this.setSession = async function ( value ) {

                session = value;

                if ( session !== null ) {

                        session.addEventListener( 'select', onSessionEvent );
                        session.addEventListener( 'selectstart', onSessionEvent );
                        session.addEventListener( 'selectend', onSessionEvent );
                        session.addEventListener( 'squeeze', onSessionEvent );
                        session.addEventListener( 'squeezestart', onSessionEvent );
                        session.addEventListener( 'squeezeend', onSessionEvent );
                        session.addEventListener( 'end', onSessionEnd );
                        session.addEventListener( 'inputsourceschange', onInputSourcesChange );

                        const attributes = gl.getContextAttributes();

                        if ( attributes.xrCompatible !== true ) {

                                await gl.makeXRCompatible();

                        }

                        const layerInit = {
                                antialias: attributes.antialias,
                                alpha: attributes.alpha,
                                depth: attributes.depth,
                                stencil: attributes.stencil,
                                framebufferScaleFactor: framebufferScaleFactor
                        };

                        // eslint-disable-next-line no-undef
                        const baseLayer = new XRWebGLLayer( session, gl, layerInit );

                        session.updateRenderState( { baseLayer: baseLayer } );

                        referenceSpace = await session.requestReferenceSpace( referenceSpaceType );

                        animation.setContext( session );
                        animation.start();

                        scope.isPresenting = true;

                        scope.dispatchEvent( { type: 'sessionstart' } );

                }

        };

        function onInputSourcesChange( event ) {

                const inputSources = session.inputSources;

                // Assign inputSources to available controllers

                for ( let i = 0; i < controllers.length; i ++ ) {

                        inputSourcesMap.set( inputSources[ i ], controllers[ i ] );

                }

                // Notify disconnected

                for ( let i = 0; i < event.removed.length; i ++ ) {

                        const inputSource = event.removed[ i ];
                        const controller = inputSourcesMap.get( inputSource );

                        if ( controller ) {

                                controller.dispatchEvent( { type: 'disconnected', data: inputSource } );
                                inputSourcesMap.delete( inputSource );

                        }

                }

                // Notify connected

                for ( let i = 0; i < event.added.length; i ++ ) {

                        const inputSource = event.added[ i ];
                        const controller = inputSourcesMap.get( inputSource );

                        if ( controller ) {

                                controller.dispatchEvent( { type: 'connected', data: inputSource } );

                        }

                }

        }

        //

        const cameraLPos = new Vector3();
        const cameraRPos = new Vector3();

        /**
         * Assumes 2 cameras that are parallel and share an X-axis, and that
         * the cameras' projection and world matrices have already been set.
         * And that near and far planes are identical for both cameras.
         * Visualization of this technique: https://computergraphics.stackexchange.com/a/4765
         */
        function setProjectionFromUnion( camera, cameraL, cameraR ) {

                cameraLPos.setFromMatrixPosition( cameraL.matrixWorld );
                cameraRPos.setFromMatrixPosition( cameraR.matrixWorld );

                const ipd = cameraLPos.distanceTo( cameraRPos );

                const projL = cameraL.projectionMatrix.elements;
                const projR = cameraR.projectionMatrix.elements;

                // VR systems will have identical far and near planes, and
                // most likely identical top and bottom frustum extents.
                // Use the left camera for these values.
                const near = projL[ 14 ] / ( projL[ 10 ] - 1 );
                const far = projL[ 14 ] / ( projL[ 10 ] + 1 );
                const topFov = ( projL[ 9 ] + 1 ) / projL[ 5 ];
                const bottomFov = ( projL[ 9 ] - 1 ) / projL[ 5 ];

                const leftFov = ( projL[ 8 ] - 1 ) / projL[ 0 ];
                const rightFov = ( projR[ 8 ] + 1 ) / projR[ 0 ];
                const left = near * leftFov;
                const right = near * rightFov;

                // Calculate the new camera's position offset from the
                // left camera. xOffset should be roughly half `ipd`.
                const zOffset = ipd / ( - leftFov + rightFov );
                const xOffset = zOffset * - leftFov;

                // TODO: Better way to apply this offset?
                cameraL.matrixWorld.decompose( camera.position, camera.quaternion, camera.scale );
                camera.translateX( xOffset );
                camera.translateZ( zOffset );
                camera.matrixWorld.compose( camera.position, camera.quaternion, camera.scale );
                camera.matrixWorldInverse.copy( camera.matrixWorld ).invert();

                // Find the union of the frustum values of the cameras and scale
                // the values so that the near plane's position does not change in world space,
                // although must now be relative to the new union camera.
                const near2 = near + zOffset;
                const far2 = far + zOffset;
                const left2 = left - xOffset;
                const right2 = right + ( ipd - xOffset );
                const top2 = topFov * far / far2 * near2;
                const bottom2 = bottomFov * far / far2 * near2;

                camera.projectionMatrix.makePerspective( left2, right2, top2, bottom2, near2, far2 );

        }

        function updateCamera( camera, parent ) {

                if ( parent === null ) {

                        camera.matrixWorld.copy( camera.matrix );

                } else {

                        camera.matrixWorld.multiplyMatrices( parent.matrixWorld, camera.matrix );

                }

                camera.matrixWorldInverse.copy( camera.matrixWorld ).invert();

        }

        this.getCamera = function ( camera ) {

                cameraVR.near = cameraR.near = cameraL.near = camera.near;
                cameraVR.far = cameraR.far = cameraL.far = camera.far;

                if ( _currentDepthNear !== cameraVR.near || _currentDepthFar !== cameraVR.far ) {

                        // Note that the new renderState won't apply until the next frame. See #18320

                        session.updateRenderState( {
                                depthNear: cameraVR.near,
                                depthFar: cameraVR.far
                        } );

                        _currentDepthNear = cameraVR.near;
                        _currentDepthFar = cameraVR.far;

                }

                const parent = camera.parent;
                const cameras = cameraVR.cameras;

                updateCamera( cameraVR, parent );

                for ( let i = 0; i < cameras.length; i ++ ) {

                        updateCamera( cameras[ i ], parent );

                }

                // update camera and its children

                camera.matrixWorld.copy( cameraVR.matrixWorld );
                camera.matrix.copy( cameraVR.matrix );
                camera.matrix.decompose( camera.position, camera.quaternion, camera.scale );

                const children = camera.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        children[ i ].updateMatrixWorld( true );

                }

                // update projection matrix for proper view frustum culling

                if ( cameras.length === 2 ) {

                        setProjectionFromUnion( cameraVR, cameraL, cameraR );

                } else {

                        // assume single camera setup (AR)

                        cameraVR.projectionMatrix.copy( cameraL.projectionMatrix );

                }

                return cameraVR;

        };

        // Animation Loop

        let onAnimationFrameCallback = null;

        function onAnimationFrame( time, frame ) {

                pose = frame.getViewerPose( referenceSpace );

                if ( pose !== null ) {

                        const views = pose.views;
                        const baseLayer = session.renderState.baseLayer;

                        renderer.setFramebuffer( baseLayer.framebuffer );

                        let cameraVRNeedsUpdate = false;

                        // check if it's necessary to rebuild cameraVR's camera list

                        if ( views.length !== cameraVR.cameras.length ) {

                                cameraVR.cameras.length = 0;
                                cameraVRNeedsUpdate = true;

                        }

                        for ( let i = 0; i < views.length; i ++ ) {

                                const view = views[ i ];
                                const viewport = baseLayer.getViewport( view );

                                const camera = cameras[ i ];
                                camera.matrix.fromArray( view.transform.matrix );
                                camera.projectionMatrix.fromArray( view.projectionMatrix );
                                camera.viewport.set( viewport.x, viewport.y, viewport.width, viewport.height );

                                if ( i === 0 ) {

                                        cameraVR.matrix.copy( camera.matrix );

                                }

                                if ( cameraVRNeedsUpdate === true ) {

                                        cameraVR.cameras.push( camera );

                                }

                        }

                }

                //

                const inputSources = session.inputSources;

                for ( let i = 0; i < controllers.length; i ++ ) {

                        const controller = controllers[ i ];
                        const inputSource = inputSources[ i ];

                        controller.update( inputSource, frame, referenceSpace );

                }

                if ( onAnimationFrameCallback ) onAnimationFrameCallback( time, frame );

        }

        const animation = new WebGLAnimation();
        animation.setAnimationLoop( onAnimationFrame );

        this.setAnimationLoop = function ( callback ) {

                onAnimationFrameCallback = callback;

        };

        this.dispose = function () {};

    }

    Object.assign( WebXRManager.prototype, EventDispatcher.prototype );

    function WebGLMaterials( properties ) {

        function refreshFogUniforms( uniforms, fog ) {

                uniforms.fogColor.value.copy( fog.color );

                if ( fog.isFog ) {

                        uniforms.fogNear.value = fog.near;
                        uniforms.fogFar.value = fog.far;

                } else if ( fog.isFogExp2 ) {

                        uniforms.fogDensity.value = fog.density;

                }

        }

        function refreshMaterialUniforms( uniforms, material, pixelRatio, height ) {

                if ( material.isMeshBasicMaterial ) {

                        refreshUniformsCommon( uniforms, material );

                } else if ( material.isMeshLambertMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsLambert( uniforms, material );

                } else if ( material.isMeshToonMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsToon( uniforms, material );

                } else if ( material.isMeshPhongMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsPhong( uniforms, material );

                } else if ( material.isMeshStandardMaterial ) {

                        refreshUniformsCommon( uniforms, material );

                        if ( material.isMeshPhysicalMaterial ) {

                                refreshUniformsPhysical( uniforms, material );

                        } else {

                                refreshUniformsStandard( uniforms, material );

                        }

                } else if ( material.isMeshMatcapMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsMatcap( uniforms, material );

                } else if ( material.isMeshDepthMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsDepth( uniforms, material );

                } else if ( material.isMeshDistanceMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsDistance( uniforms, material );

                } else if ( material.isMeshNormalMaterial ) {

                        refreshUniformsCommon( uniforms, material );
                        refreshUniformsNormal( uniforms, material );

                } else if ( material.isLineBasicMaterial ) {

                        refreshUniformsLine( uniforms, material );

                        if ( material.isLineDashedMaterial ) {

                                refreshUniformsDash( uniforms, material );

                        }

                } else if ( material.isPointsMaterial ) {

                        refreshUniformsPoints( uniforms, material, pixelRatio, height );

                } else if ( material.isSpriteMaterial ) {

                        refreshUniformsSprites( uniforms, material );

                } else if ( material.isShadowMaterial ) {

                        uniforms.color.value.copy( material.color );
                        uniforms.opacity.value = material.opacity;

                } else if ( material.isShaderMaterial ) {

                        material.uniformsNeedUpdate = false; // #15581

                }

        }

        function refreshUniformsCommon( uniforms, material ) {

                uniforms.opacity.value = material.opacity;

                if ( material.color ) {

                        uniforms.diffuse.value.copy( material.color );

                }

                if ( material.emissive ) {

                        uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );

                }

                if ( material.map ) {

                        uniforms.map.value = material.map;

                }

                if ( material.alphaMap ) {

                        uniforms.alphaMap.value = material.alphaMap;

                }

                if ( material.specularMap ) {

                        uniforms.specularMap.value = material.specularMap;

                }

                const envMap = properties.get( material ).envMap;

                if ( envMap ) {

                        uniforms.envMap.value = envMap;

                        uniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap._needsFlipEnvMap ) ? - 1 : 1;

                        uniforms.reflectivity.value = material.reflectivity;
                        uniforms.refractionRatio.value = material.refractionRatio;

                        const maxMipLevel = properties.get( envMap ).__maxMipLevel;

                        if ( maxMipLevel !== undefined ) {

                                uniforms.maxMipLevel.value = maxMipLevel;

                        }

                }

                if ( material.lightMap ) {

                        uniforms.lightMap.value = material.lightMap;
                        uniforms.lightMapIntensity.value = material.lightMapIntensity;

                }

                if ( material.aoMap ) {

                        uniforms.aoMap.value = material.aoMap;
                        uniforms.aoMapIntensity.value = material.aoMapIntensity;

                }

                // uv repeat and offset setting priorities
                // 1. color map
                // 2. specular map
                // 3. displacementMap map
                // 4. normal map
                // 5. bump map
                // 6. roughnessMap map
                // 7. metalnessMap map
                // 8. alphaMap map
                // 9. emissiveMap map
                // 10. clearcoat map
                // 11. clearcoat normal map
                // 12. clearcoat roughnessMap map

                let uvScaleMap;

                if ( material.map ) {

                        uvScaleMap = material.map;

                } else if ( material.specularMap ) {

                        uvScaleMap = material.specularMap;

                } else if ( material.displacementMap ) {

                        uvScaleMap = material.displacementMap;

                } else if ( material.normalMap ) {

                        uvScaleMap = material.normalMap;

                } else if ( material.bumpMap ) {

                        uvScaleMap = material.bumpMap;

                } else if ( material.roughnessMap ) {

                        uvScaleMap = material.roughnessMap;

                } else if ( material.metalnessMap ) {

                        uvScaleMap = material.metalnessMap;

                } else if ( material.alphaMap ) {

                        uvScaleMap = material.alphaMap;

                } else if ( material.emissiveMap ) {

                        uvScaleMap = material.emissiveMap;

                } else if ( material.clearcoatMap ) {

                        uvScaleMap = material.clearcoatMap;

                } else if ( material.clearcoatNormalMap ) {

                        uvScaleMap = material.clearcoatNormalMap;

                } else if ( material.clearcoatRoughnessMap ) {

                        uvScaleMap = material.clearcoatRoughnessMap;

                }

                if ( uvScaleMap !== undefined ) {

                        // backwards compatibility
                        if ( uvScaleMap.isWebGLRenderTarget ) {

                                uvScaleMap = uvScaleMap.texture;

                        }

                        if ( uvScaleMap.matrixAutoUpdate === true ) {

                                uvScaleMap.updateMatrix();

                        }

                        uniforms.uvTransform.value.copy( uvScaleMap.matrix );

                }

                // uv repeat and offset setting priorities for uv2
                // 1. ao map
                // 2. light map

                let uv2ScaleMap;

                if ( material.aoMap ) {

                        uv2ScaleMap = material.aoMap;

                } else if ( material.lightMap ) {

                        uv2ScaleMap = material.lightMap;

                }

                if ( uv2ScaleMap !== undefined ) {

                        // backwards compatibility
                        if ( uv2ScaleMap.isWebGLRenderTarget ) {

                                uv2ScaleMap = uv2ScaleMap.texture;

                        }

                        if ( uv2ScaleMap.matrixAutoUpdate === true ) {

                                uv2ScaleMap.updateMatrix();

                        }

                        uniforms.uv2Transform.value.copy( uv2ScaleMap.matrix );

                }

        }

        function refreshUniformsLine( uniforms, material ) {

                uniforms.diffuse.value.copy( material.color );
                uniforms.opacity.value = material.opacity;

        }

        function refreshUniformsDash( uniforms, material ) {

                uniforms.dashSize.value = material.dashSize;
                uniforms.totalSize.value = material.dashSize + material.gapSize;
                uniforms.scale.value = material.scale;

        }

        function refreshUniformsPoints( uniforms, material, pixelRatio, height ) {

                uniforms.diffuse.value.copy( material.color );
                uniforms.opacity.value = material.opacity;
                uniforms.size.value = material.size * pixelRatio;
                uniforms.scale.value = height * 0.5;

                if ( material.map ) {

                        uniforms.map.value = material.map;

                }

                if ( material.alphaMap ) {

                        uniforms.alphaMap.value = material.alphaMap;

                }

                // uv repeat and offset setting priorities
                // 1. color map
                // 2. alpha map

                let uvScaleMap;

                if ( material.map ) {

                        uvScaleMap = material.map;

                } else if ( material.alphaMap ) {

                        uvScaleMap = material.alphaMap;

                }

                if ( uvScaleMap !== undefined ) {

                        if ( uvScaleMap.matrixAutoUpdate === true ) {

                                uvScaleMap.updateMatrix();

                        }

                        uniforms.uvTransform.value.copy( uvScaleMap.matrix );

                }

        }

        function refreshUniformsSprites( uniforms, material ) {

                uniforms.diffuse.value.copy( material.color );
                uniforms.opacity.value = material.opacity;
                uniforms.rotation.value = material.rotation;

                if ( material.map ) {

                        uniforms.map.value = material.map;

                }

                if ( material.alphaMap ) {

                        uniforms.alphaMap.value = material.alphaMap;

                }

                // uv repeat and offset setting priorities
                // 1. color map
                // 2. alpha map

                let uvScaleMap;

                if ( material.map ) {

                        uvScaleMap = material.map;

                } else if ( material.alphaMap ) {

                        uvScaleMap = material.alphaMap;

                }

                if ( uvScaleMap !== undefined ) {

                        if ( uvScaleMap.matrixAutoUpdate === true ) {

                                uvScaleMap.updateMatrix();

                        }

                        uniforms.uvTransform.value.copy( uvScaleMap.matrix );

                }

        }

        function refreshUniformsLambert( uniforms, material ) {

                if ( material.emissiveMap ) {

                        uniforms.emissiveMap.value = material.emissiveMap;

                }

        }

        function refreshUniformsPhong( uniforms, material ) {

                uniforms.specular.value.copy( material.specular );
                uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )

                if ( material.emissiveMap ) {

                        uniforms.emissiveMap.value = material.emissiveMap;

                }

                if ( material.bumpMap ) {

                        uniforms.bumpMap.value = material.bumpMap;
                        uniforms.bumpScale.value = material.bumpScale;
                        if ( material.side === BackSide ) uniforms.bumpScale.value *= - 1;

                }

                if ( material.normalMap ) {

                        uniforms.normalMap.value = material.normalMap;
                        uniforms.normalScale.value.copy( material.normalScale );
                        if ( material.side === BackSide ) uniforms.normalScale.value.negate();

                }

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

        }

        function refreshUniformsToon( uniforms, material ) {

                if ( material.gradientMap ) {

                        uniforms.gradientMap.value = material.gradientMap;

                }

                if ( material.emissiveMap ) {

                        uniforms.emissiveMap.value = material.emissiveMap;

                }

                if ( material.bumpMap ) {

                        uniforms.bumpMap.value = material.bumpMap;
                        uniforms.bumpScale.value = material.bumpScale;
                        if ( material.side === BackSide ) uniforms.bumpScale.value *= - 1;

                }

                if ( material.normalMap ) {

                        uniforms.normalMap.value = material.normalMap;
                        uniforms.normalScale.value.copy( material.normalScale );
                        if ( material.side === BackSide ) uniforms.normalScale.value.negate();

                }

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

        }

        function refreshUniformsStandard( uniforms, material ) {

                uniforms.roughness.value = material.roughness;
                uniforms.metalness.value = material.metalness;

                if ( material.roughnessMap ) {

                        uniforms.roughnessMap.value = material.roughnessMap;

                }

                if ( material.metalnessMap ) {

                        uniforms.metalnessMap.value = material.metalnessMap;

                }

                if ( material.emissiveMap ) {

                        uniforms.emissiveMap.value = material.emissiveMap;

                }

                if ( material.bumpMap ) {

                        uniforms.bumpMap.value = material.bumpMap;
                        uniforms.bumpScale.value = material.bumpScale;
                        if ( material.side === BackSide ) uniforms.bumpScale.value *= - 1;

                }

                if ( material.normalMap ) {

                        uniforms.normalMap.value = material.normalMap;
                        uniforms.normalScale.value.copy( material.normalScale );
                        if ( material.side === BackSide ) uniforms.normalScale.value.negate();

                }

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

                const envMap = properties.get( material ).envMap;

                if ( envMap ) {

                        //uniforms.envMap.value = material.envMap; // part of uniforms common
                        uniforms.envMapIntensity.value = material.envMapIntensity;

                }

        }

        function refreshUniformsPhysical( uniforms, material ) {

                refreshUniformsStandard( uniforms, material );

                uniforms.reflectivity.value = material.reflectivity; // also part of uniforms common

                uniforms.clearcoat.value = material.clearcoat;
                uniforms.clearcoatRoughness.value = material.clearcoatRoughness;
                if ( material.sheen ) uniforms.sheen.value.copy( material.sheen );

                if ( material.clearcoatMap ) {

                        uniforms.clearcoatMap.value = material.clearcoatMap;

                }

                if ( material.clearcoatRoughnessMap ) {

                        uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap;

                }

                if ( material.clearcoatNormalMap ) {

                        uniforms.clearcoatNormalScale.value.copy( material.clearcoatNormalScale );
                        uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap;

                        if ( material.side === BackSide ) {

                                uniforms.clearcoatNormalScale.value.negate();

                        }

                }

                uniforms.transmission.value = material.transmission;

                if ( material.transmissionMap ) {

                        uniforms.transmissionMap.value = material.transmissionMap;

                }

        }

        function refreshUniformsMatcap( uniforms, material ) {

                if ( material.matcap ) {

                        uniforms.matcap.value = material.matcap;

                }

                if ( material.bumpMap ) {

                        uniforms.bumpMap.value = material.bumpMap;
                        uniforms.bumpScale.value = material.bumpScale;
                        if ( material.side === BackSide ) uniforms.bumpScale.value *= - 1;

                }

                if ( material.normalMap ) {

                        uniforms.normalMap.value = material.normalMap;
                        uniforms.normalScale.value.copy( material.normalScale );
                        if ( material.side === BackSide ) uniforms.normalScale.value.negate();

                }

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

        }

        function refreshUniformsDepth( uniforms, material ) {

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

        }

        function refreshUniformsDistance( uniforms, material ) {

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

                uniforms.referencePosition.value.copy( material.referencePosition );
                uniforms.nearDistance.value = material.nearDistance;
                uniforms.farDistance.value = material.farDistance;

        }

        function refreshUniformsNormal( uniforms, material ) {

                if ( material.bumpMap ) {

                        uniforms.bumpMap.value = material.bumpMap;
                        uniforms.bumpScale.value = material.bumpScale;
                        if ( material.side === BackSide ) uniforms.bumpScale.value *= - 1;

                }

                if ( material.normalMap ) {

                        uniforms.normalMap.value = material.normalMap;
                        uniforms.normalScale.value.copy( material.normalScale );
                        if ( material.side === BackSide ) uniforms.normalScale.value.negate();

                }

                if ( material.displacementMap ) {

                        uniforms.displacementMap.value = material.displacementMap;
                        uniforms.displacementScale.value = material.displacementScale;
                        uniforms.displacementBias.value = material.displacementBias;

                }

        }

        return {
                refreshFogUniforms: refreshFogUniforms,
                refreshMaterialUniforms: refreshMaterialUniforms
        };

    }

    function createCanvasElement() {

        const canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );
        canvas.style.display = 'block';
        return canvas;

    }

    function WebGLRenderer( parameters ) {

        parameters = parameters || {};

        const _canvas = parameters.canvas !== undefined ? parameters.canvas : createCanvasElement(),
                _context = parameters.context !== undefined ? parameters.context : null,

                _alpha = parameters.alpha !== undefined ? parameters.alpha : false,
                _depth = parameters.depth !== undefined ? parameters.depth : true,
                _stencil = parameters.stencil !== undefined ? parameters.stencil : true,
                _antialias = parameters.antialias !== undefined ? parameters.antialias : false,
                _premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,
                _preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false,
                _powerPreference = parameters.powerPreference !== undefined ? parameters.powerPreference : 'default',
                _failIfMajorPerformanceCaveat = parameters.failIfMajorPerformanceCaveat !== undefined ? parameters.failIfMajorPerformanceCaveat : false;

        let currentRenderList = null;
        let currentRenderState = null;

        // render() can be called from within a callback triggered by another render.
        // We track this so that the nested render call gets its state isolated from the parent render call.

        const renderStateStack = [];

        // public properties

        this.domElement = _canvas;

        // Debug configuration container
        this.debug = {

                /**
                 * Enables error checking and reporting when shader programs are being compiled
                 * @type {boolean}
                 */
                checkShaderErrors: true
        };

        // clearing

        this.autoClear = true;
        this.autoClearColor = true;
        this.autoClearDepth = true;
        this.autoClearStencil = true;

        // scene graph

        this.sortObjects = true;

        // user-defined clipping

        this.clippingPlanes = [];
        this.localClippingEnabled = false;

        // physically based shading

        this.gammaFactor = 2.0; // for backwards compatibility
        this.outputEncoding = LinearEncoding;

        // physical lights

        this.physicallyCorrectLights = false;

        // tone mapping

        this.toneMapping = NoToneMapping;
        this.toneMappingExposure = 1.0;

        // morphs

        this.maxMorphTargets = 8;
        this.maxMorphNormals = 4;

        // internal properties

        const _this = this;

        let _isContextLost = false;

        // internal state cache

        let _framebuffer = null;

        let _currentActiveCubeFace = 0;
        let _currentActiveMipmapLevel = 0;
        let _currentRenderTarget = null;
        let _currentFramebuffer = null;
        let _currentMaterialId = - 1;

        let _currentCamera = null;

        const _currentViewport = new Vector4();
        const _currentScissor = new Vector4();
        let _currentScissorTest = null;

        //

        let _width = _canvas.width;
        let _height = _canvas.height;

        let _pixelRatio = 1;
        let _opaqueSort = null;
        let _transparentSort = null;

        const _viewport = new Vector4( 0, 0, _width, _height );
        const _scissor = new Vector4( 0, 0, _width, _height );
        let _scissorTest = false;

        // frustum

        const _frustum = new Frustum();

        // clipping

        let _clippingEnabled = false;
        let _localClippingEnabled = false;

        // camera matrices cache

        const _projScreenMatrix = new Matrix4();

        const _vector3 = new Vector3();

        const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };

        function getTargetPixelRatio() {

                return _currentRenderTarget === null ? _pixelRatio : 1;

        }

        // initialize

        let _gl = _context;

        function getContext( contextNames, contextAttributes ) {

                for ( let i = 0; i < contextNames.length; i ++ ) {

                        const contextName = contextNames[ i ];
                        const context = _canvas.getContext( contextName, contextAttributes );
                        if ( context !== null ) return context;

                }

                return null;

        }

        try {

                const contextAttributes = {
                        alpha: _alpha,
                        depth: _depth,
                        stencil: _stencil,
                        antialias: _antialias,
                        premultipliedAlpha: _premultipliedAlpha,
                        preserveDrawingBuffer: _preserveDrawingBuffer,
                        powerPreference: _powerPreference,
                        failIfMajorPerformanceCaveat: _failIfMajorPerformanceCaveat
                };

                // event listeners must be registered before WebGL context is created, see #12753

                _canvas.addEventListener( 'webglcontextlost', onContextLost, false );
                _canvas.addEventListener( 'webglcontextrestored', onContextRestore, false );

                if ( _gl === null ) {

                        const contextNames = [ 'webgl2', 'webgl', 'experimental-webgl' ];

                        if ( _this.isWebGL1Renderer === true ) {

                                contextNames.shift();

                        }

                        _gl = getContext( contextNames, contextAttributes );

                        if ( _gl === null ) {

                                if ( getContext( contextNames ) ) {

                                        throw new Error( 'Error creating WebGL context with your selected attributes.' );

                                } else {

                                        throw new Error( 'Error creating WebGL context.' );

                                }

                        }

                }

                // Some experimental-webgl implementations do not have getShaderPrecisionFormat

                if ( _gl.getShaderPrecisionFormat === undefined ) {

                        _gl.getShaderPrecisionFormat = function () {

                                return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };

                        };

                }

        } catch ( error ) {

                console.error( 'THREE.WebGLRenderer: ' + error.message );
                throw error;

        }

        let extensions, capabilities, state, info;
        let properties, textures, cubemaps, attributes, geometries, objects;
        let programCache, materials, renderLists, renderStates, clipping;

        let background, morphtargets, bufferRenderer, indexedBufferRenderer;

        let utils, bindingStates;

        function initGLContext() {

                extensions = new WebGLExtensions( _gl );

                capabilities = new WebGLCapabilities( _gl, extensions, parameters );

                extensions.init( capabilities );

                utils = new WebGLUtils( _gl, extensions, capabilities );

                state = new WebGLState( _gl, extensions, capabilities );
                state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor() );
                state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor() );

                info = new WebGLInfo( _gl );
                properties = new WebGLProperties();
                textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info );
                cubemaps = new WebGLCubeMaps( _this );
                attributes = new WebGLAttributes( _gl, capabilities );
                bindingStates = new WebGLBindingStates( _gl, extensions, attributes, capabilities );
                geometries = new WebGLGeometries( _gl, attributes, info, bindingStates );
                objects = new WebGLObjects( _gl, geometries, attributes, info );
                morphtargets = new WebGLMorphtargets( _gl );
                clipping = new WebGLClipping( properties );
                programCache = new WebGLPrograms( _this, cubemaps, extensions, capabilities, bindingStates, clipping );
                materials = new WebGLMaterials( properties );
                renderLists = new WebGLRenderLists( properties );
                renderStates = new WebGLRenderStates( extensions, capabilities );
                background = new WebGLBackground( _this, cubemaps, state, objects, _premultipliedAlpha );

                bufferRenderer = new WebGLBufferRenderer( _gl, extensions, info, capabilities );
                indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, info, capabilities );

                info.programs = programCache.programs;

                _this.capabilities = capabilities;
                _this.extensions = extensions;
                _this.properties = properties;
                _this.renderLists = renderLists;
                _this.state = state;
                _this.info = info;

        }

        initGLContext();

        // xr

        const xr = new WebXRManager( _this, _gl );

        this.xr = xr;

        // shadow map

        const shadowMap = new WebGLShadowMap( _this, objects, capabilities.maxTextureSize );

        this.shadowMap = shadowMap;

        // API

        this.getContext = function () {

                return _gl;

        };

        this.getContextAttributes = function () {

                return _gl.getContextAttributes();

        };

        this.forceContextLoss = function () {

                const extension = extensions.get( 'WEBGL_lose_context' );
                if ( extension ) extension.loseContext();

        };

        this.forceContextRestore = function () {

                const extension = extensions.get( 'WEBGL_lose_context' );
                if ( extension ) extension.restoreContext();

        };

        this.getPixelRatio = function () {

                return _pixelRatio;

        };

        this.setPixelRatio = function ( value ) {

                if ( value === undefined ) return;

                _pixelRatio = value;

                this.setSize( _width, _height, false );

        };

        this.getSize = function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'WebGLRenderer: .getsize() now requires a Vector2 as an argument' );

                        target = new Vector2();

                }

                return target.set( _width, _height );

        };

        this.setSize = function ( width, height, updateStyle ) {

                if ( xr.isPresenting ) {

                        console.warn( 'THREE.WebGLRenderer: Can\'t change size while VR device is presenting.' );
                        return;

                }

                _width = width;
                _height = height;

                _canvas.width = Math.floor( width * _pixelRatio );
                _canvas.height = Math.floor( height * _pixelRatio );

                if ( updateStyle !== false ) {

                        _canvas.style.width = width + 'px';
                        _canvas.style.height = height + 'px';

                }

                this.setViewport( 0, 0, width, height );

        };

        this.getDrawingBufferSize = function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument' );

                        target = new Vector2();

                }

                return target.set( _width * _pixelRatio, _height * _pixelRatio ).floor();

        };

        this.setDrawingBufferSize = function ( width, height, pixelRatio ) {

                _width = width;
                _height = height;

                _pixelRatio = pixelRatio;

                _canvas.width = Math.floor( width * pixelRatio );
                _canvas.height = Math.floor( height * pixelRatio );

                this.setViewport( 0, 0, width, height );

        };

        this.getCurrentViewport = function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument' );

                        target = new Vector4();

                }

                return target.copy( _currentViewport );

        };

        this.getViewport = function ( target ) {

                return target.copy( _viewport );

        };

        this.setViewport = function ( x, y, width, height ) {

                if ( x.isVector4 ) {

                        _viewport.set( x.x, x.y, x.z, x.w );

                } else {

                        _viewport.set( x, y, width, height );

                }

                state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor() );

        };

        this.getScissor = function ( target ) {

                return target.copy( _scissor );

        };

        this.setScissor = function ( x, y, width, height ) {

                if ( x.isVector4 ) {

                        _scissor.set( x.x, x.y, x.z, x.w );

                } else {

                        _scissor.set( x, y, width, height );

                }

                state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor() );

        };

        this.getScissorTest = function () {

                return _scissorTest;

        };

        this.setScissorTest = function ( boolean ) {

                state.setScissorTest( _scissorTest = boolean );

        };

        this.setOpaqueSort = function ( method ) {

                _opaqueSort = method;

        };

        this.setTransparentSort = function ( method ) {

                _transparentSort = method;

        };

        // Clearing

        this.getClearColor = function ( target ) {

                if ( target === undefined ) {

                        console.warn( 'WebGLRenderer: .getClearColor() now requires a Color as an argument' );

                        target = new Color();

                }

                return target.copy( background.getClearColor() );

        };

        this.setClearColor = function () {

                background.setClearColor.apply( background, arguments );

        };

        this.getClearAlpha = function () {

                return background.getClearAlpha();

        };

        this.setClearAlpha = function () {

                background.setClearAlpha.apply( background, arguments );

        };

        this.clear = function ( color, depth, stencil ) {

                let bits = 0;

                if ( color === undefined || color ) bits |= 16384;
                if ( depth === undefined || depth ) bits |= 256;
                if ( stencil === undefined || stencil ) bits |= 1024;

                _gl.clear( bits );

        };

        this.clearColor = function () {

                this.clear( true, false, false );

        };

        this.clearDepth = function () {

                this.clear( false, true, false );

        };

        this.clearStencil = function () {

                this.clear( false, false, true );

        };

        //

        this.dispose = function () {

                _canvas.removeEventListener( 'webglcontextlost', onContextLost, false );
                _canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );

                renderLists.dispose();
                renderStates.dispose();
                properties.dispose();
                cubemaps.dispose();
                objects.dispose();
                bindingStates.dispose();

                xr.dispose();

                animation.stop();

        };

        // Events

        function onContextLost( event ) {

                event.preventDefault();

                console.log( 'THREE.WebGLRenderer: Context Lost.' );

                _isContextLost = true;

        }

        function onContextRestore( /* event */ ) {

                console.log( 'THREE.WebGLRenderer: Context Restored.' );

                _isContextLost = false;

                initGLContext();

        }

        function onMaterialDispose( event ) {

                const material = event.target;

                material.removeEventListener( 'dispose', onMaterialDispose );

                deallocateMaterial( material );

        }

        // Buffer deallocation

        function deallocateMaterial( material ) {

                releaseMaterialProgramReference( material );

                properties.remove( material );

        }


        function releaseMaterialProgramReference( material ) {

                const programInfo = properties.get( material ).program;

                if ( programInfo !== undefined ) {

                        programCache.releaseProgram( programInfo );

                }

        }

        // Buffer rendering

        function renderObjectImmediate( object, program ) {

                object.render( function ( object ) {

                        _this.renderBufferImmediate( object, program );

                } );

        }

        this.renderBufferImmediate = function ( object, program ) {

                bindingStates.initAttributes();

                const buffers = properties.get( object );

                if ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer();
                if ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer();
                if ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer();
                if ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer();

                const programAttributes = program.getAttributes();

                if ( object.hasPositions ) {

                        _gl.bindBuffer( 34962, buffers.position );
                        _gl.bufferData( 34962, object.positionArray, 35048 );

                        bindingStates.enableAttribute( programAttributes.position );
                        _gl.vertexAttribPointer( programAttributes.position, 3, 5126, false, 0, 0 );

                }

                if ( object.hasNormals ) {

                        _gl.bindBuffer( 34962, buffers.normal );
                        _gl.bufferData( 34962, object.normalArray, 35048 );

                        bindingStates.enableAttribute( programAttributes.normal );
                        _gl.vertexAttribPointer( programAttributes.normal, 3, 5126, false, 0, 0 );

                }

                if ( object.hasUvs ) {

                        _gl.bindBuffer( 34962, buffers.uv );
                        _gl.bufferData( 34962, object.uvArray, 35048 );

                        bindingStates.enableAttribute( programAttributes.uv );
                        _gl.vertexAttribPointer( programAttributes.uv, 2, 5126, false, 0, 0 );

                }

                if ( object.hasColors ) {

                        _gl.bindBuffer( 34962, buffers.color );
                        _gl.bufferData( 34962, object.colorArray, 35048 );

                        bindingStates.enableAttribute( programAttributes.color );
                        _gl.vertexAttribPointer( programAttributes.color, 3, 5126, false, 0, 0 );

                }

                bindingStates.disableUnusedAttributes();

                _gl.drawArrays( 4, 0, object.count );

                object.count = 0;

        };

        this.renderBufferDirect = function ( camera, scene, geometry, material, object, group ) {

                if ( scene === null ) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)

                const frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );

                const program = setProgram( camera, scene, material, object );

                state.setMaterial( material, frontFaceCW );

                //

                let index = geometry.index;
                const position = geometry.attributes.position;

                //

                if ( index === null ) {

                        if ( position === undefined || position.count === 0 ) return;

                } else if ( index.count === 0 ) {

                        return;

                }

                //

                let rangeFactor = 1;

                if ( material.wireframe === true ) {

                        index = geometries.getWireframeAttribute( geometry );
                        rangeFactor = 2;

                }

                if ( material.morphTargets || material.morphNormals ) {

                        morphtargets.update( object, geometry, material, program );

                }

                bindingStates.setup( object, material, program, geometry, index );

                let attribute;
                let renderer = bufferRenderer;

                if ( index !== null ) {

                        attribute = attributes.get( index );

                        renderer = indexedBufferRenderer;
                        renderer.setIndex( attribute );

                }

                //

                const dataCount = ( index !== null ) ? index.count : position.count;

                const rangeStart = geometry.drawRange.start * rangeFactor;
                const rangeCount = geometry.drawRange.count * rangeFactor;

                const groupStart = group !== null ? group.start * rangeFactor : 0;
                const groupCount = group !== null ? group.count * rangeFactor : Infinity;

                const drawStart = Math.max( rangeStart, groupStart );
                const drawEnd = Math.min( dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1;

                const drawCount = Math.max( 0, drawEnd - drawStart + 1 );

                if ( drawCount === 0 ) return;

                //

                if ( object.isMesh ) {

                        if ( material.wireframe === true ) {

                                state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );
                                renderer.setMode( 1 );

                        } else {

                                renderer.setMode( 4 );

                        }

                } else if ( object.isLine ) {

                        let lineWidth = material.linewidth;

                        if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material

                        state.setLineWidth( lineWidth * getTargetPixelRatio() );

                        if ( object.isLineSegments ) {

                                renderer.setMode( 1 );

                        } else if ( object.isLineLoop ) {

                                renderer.setMode( 2 );

                        } else {

                                renderer.setMode( 3 );

                        }

                } else if ( object.isPoints ) {

                        renderer.setMode( 0 );

                } else if ( object.isSprite ) {

                        renderer.setMode( 4 );

                }

                if ( object.isInstancedMesh ) {

                        renderer.renderInstances( drawStart, drawCount, object.count );

                } else if ( geometry.isInstancedBufferGeometry ) {

                        const instanceCount = Math.min( geometry.instanceCount, geometry._maxInstanceCount );

                        renderer.renderInstances( drawStart, drawCount, instanceCount );

                } else {

                        renderer.render( drawStart, drawCount );

                }

        };

        // Compile

        this.compile = function ( scene, camera ) {

                currentRenderState = renderStates.get( scene );
                currentRenderState.init();

                scene.traverseVisible( function ( object ) {

                        if ( object.isLight && object.layers.test( camera.layers ) ) {

                                currentRenderState.pushLight( object );

                                if ( object.castShadow ) {

                                        currentRenderState.pushShadow( object );

                                }

                        }

                } );

                currentRenderState.setupLights();

                const compiled = new WeakMap();

                scene.traverse( function ( object ) {

                        const material = object.material;

                        if ( material ) {

                                if ( Array.isArray( material ) ) {

                                        for ( let i = 0; i < material.length; i ++ ) {

                                                const material2 = material[ i ];

                                                if ( compiled.has( material2 ) === false ) {

                                                        initMaterial( material2, scene, object );
                                                        compiled.set( material2 );

                                                }

                                        }

                                } else if ( compiled.has( material ) === false ) {

                                        initMaterial( material, scene, object );
                                        compiled.set( material );

                                }

                        }

                } );

        };

        // Animation Loop

        let onAnimationFrameCallback = null;

        function onAnimationFrame( time ) {

                if ( xr.isPresenting ) return;
                if ( onAnimationFrameCallback ) onAnimationFrameCallback( time );

        }

        const animation = new WebGLAnimation();
        animation.setAnimationLoop( onAnimationFrame );

        if ( typeof window !== 'undefined' ) animation.setContext( window );

        this.setAnimationLoop = function ( callback ) {

                onAnimationFrameCallback = callback;
                xr.setAnimationLoop( callback );

                ( callback === null ) ? animation.stop() : animation.start();

        };

        // Rendering

        this.render = function ( scene, camera ) {

                let renderTarget, forceClear;

                if ( arguments[ 2 ] !== undefined ) {

                        console.warn( 'THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.' );
                        renderTarget = arguments[ 2 ];

                }

                if ( arguments[ 3 ] !== undefined ) {

                        console.warn( 'THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead.' );
                        forceClear = arguments[ 3 ];

                }

                if ( camera !== undefined && camera.isCamera !== true ) {

                        console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );
                        return;

                }

                if ( _isContextLost === true ) return;

                // reset caching for this frame

                bindingStates.resetDefaultState();
                _currentMaterialId = - 1;
                _currentCamera = null;

                // update scene graph

                if ( scene.autoUpdate === true ) scene.updateMatrixWorld();

                // update camera matrices and frustum

                if ( camera.parent === null ) camera.updateMatrixWorld();

                if ( xr.enabled === true && xr.isPresenting === true ) {

                        camera = xr.getCamera( camera );

                }

                //
                if ( scene.isScene === true ) scene.onBeforeRender( _this, scene, camera, renderTarget || _currentRenderTarget );

                currentRenderState = renderStates.get( scene, renderStateStack.length );
                currentRenderState.init();

                renderStateStack.push( currentRenderState );

                _projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
                _frustum.setFromProjectionMatrix( _projScreenMatrix );

                _localClippingEnabled = this.localClippingEnabled;
                _clippingEnabled = clipping.init( this.clippingPlanes, _localClippingEnabled, camera );

                currentRenderList = renderLists.get( scene, camera );
                currentRenderList.init();

                projectObject( scene, camera, 0, _this.sortObjects );

                currentRenderList.finish();

                if ( _this.sortObjects === true ) {

                        currentRenderList.sort( _opaqueSort, _transparentSort );

                }

                //

                if ( _clippingEnabled === true ) clipping.beginShadows();

                const shadowsArray = currentRenderState.state.shadowsArray;

                shadowMap.render( shadowsArray, scene, camera );

                currentRenderState.setupLights();
                currentRenderState.setupLightsView( camera );

                if ( _clippingEnabled === true ) clipping.endShadows();

                //

                if ( this.info.autoReset === true ) this.info.reset();

                if ( renderTarget !== undefined ) {

                        this.setRenderTarget( renderTarget );

                }

                //

                background.render( currentRenderList, scene, camera, forceClear );

                // render scene

                const opaqueObjects = currentRenderList.opaque;
                const transparentObjects = currentRenderList.transparent;

                if ( opaqueObjects.length > 0 ) renderObjects( opaqueObjects, scene, camera );
                if ( transparentObjects.length > 0 ) renderObjects( transparentObjects, scene, camera );

                //

                if ( scene.isScene === true ) scene.onAfterRender( _this, scene, camera );

                //

                if ( _currentRenderTarget !== null ) {

                        // Generate mipmap if we're using any kind of mipmap filtering

                        textures.updateRenderTargetMipmap( _currentRenderTarget );

                        // resolve multisample renderbuffers to a single-sample texture if necessary

                        textures.updateMultisampleRenderTarget( _currentRenderTarget );

                }

                // Ensure depth buffer writing is enabled so it can be cleared on next render

                state.buffers.depth.setTest( true );
                state.buffers.depth.setMask( true );
                state.buffers.color.setMask( true );

                state.setPolygonOffset( false );

                // _gl.finish();

                renderStateStack.pop();
                if ( renderStateStack.length > 0 ) {

                        currentRenderState = renderStateStack[ renderStateStack.length - 1 ];

                } else {

                        currentRenderState = null;

                }

                currentRenderList = null;

        };

        function projectObject( object, camera, groupOrder, sortObjects ) {

                if ( object.visible === false ) return;

                const visible = object.layers.test( camera.layers );

                if ( visible ) {

                        if ( object.isGroup ) {

                                groupOrder = object.renderOrder;

                        } else if ( object.isLOD ) {

                                if ( object.autoUpdate === true ) object.update( camera );

                        } else if ( object.isLight ) {

                                currentRenderState.pushLight( object );

                                if ( object.castShadow ) {

                                        currentRenderState.pushShadow( object );

                                }

                        } else if ( object.isSprite ) {

                                if ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {

                                        if ( sortObjects ) {

                                                _vector3.setFromMatrixPosition( object.matrixWorld )
                                                        .applyMatrix4( _projScreenMatrix );

                                        }

                                        const geometry = objects.update( object );
                                        const material = object.material;

                                        if ( material.visible ) {

                                                currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );

                                        }

                                }

                        } else if ( object.isImmediateRenderObject ) {

                                if ( sortObjects ) {

                                        _vector3.setFromMatrixPosition( object.matrixWorld )
                                                .applyMatrix4( _projScreenMatrix );

                                }

                                currentRenderList.push( object, null, object.material, groupOrder, _vector3.z, null );

                        } else if ( object.isMesh || object.isLine || object.isPoints ) {

                                if ( object.isSkinnedMesh ) {

                                        // update skeleton only once in a frame

                                        if ( object.skeleton.frame !== info.render.frame ) {

                                                object.skeleton.update();
                                                object.skeleton.frame = info.render.frame;

                                        }

                                }

                                if ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {

                                        if ( sortObjects ) {

                                                _vector3.setFromMatrixPosition( object.matrixWorld )
                                                        .applyMatrix4( _projScreenMatrix );

                                        }

                                        const geometry = objects.update( object );
                                        const material = object.material;

                                        if ( Array.isArray( material ) ) {

                                                const groups = geometry.groups;

                                                for ( let i = 0, l = groups.length; i < l; i ++ ) {

                                                        const group = groups[ i ];
                                                        const groupMaterial = material[ group.materialIndex ];

                                                        if ( groupMaterial && groupMaterial.visible ) {

                                                                currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector3.z, group );

                                                        }

                                                }

                                        } else if ( material.visible ) {

                                                currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );

                                        }

                                }

                        }

                }

                const children = object.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        projectObject( children[ i ], camera, groupOrder, sortObjects );

                }

        }

        function renderObjects( renderList, scene, camera ) {

                const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;

                for ( let i = 0, l = renderList.length; i < l; i ++ ) {

                        const renderItem = renderList[ i ];

                        const object = renderItem.object;
                        const geometry = renderItem.geometry;
                        const material = overrideMaterial === null ? renderItem.material : overrideMaterial;
                        const group = renderItem.group;

                        if ( camera.isArrayCamera ) {

                                const cameras = camera.cameras;

                                for ( let j = 0, jl = cameras.length; j < jl; j ++ ) {

                                        const camera2 = cameras[ j ];

                                        if ( object.layers.test( camera2.layers ) ) {

                                                state.viewport( _currentViewport.copy( camera2.viewport ) );

                                                currentRenderState.setupLightsView( camera2 );

                                                renderObject( object, scene, camera2, geometry, material, group );

                                        }

                                }

                        } else {

                                renderObject( object, scene, camera, geometry, material, group );

                        }

                }

        }

        function renderObject( object, scene, camera, geometry, material, group ) {

                object.onBeforeRender( _this, scene, camera, geometry, material, group );

                object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
                object.normalMatrix.getNormalMatrix( object.modelViewMatrix );

                if ( object.isImmediateRenderObject ) {

                        const program = setProgram( camera, scene, material, object );

                        state.setMaterial( material );

                        bindingStates.reset();

                        renderObjectImmediate( object, program );

                } else {

                        _this.renderBufferDirect( camera, scene, geometry, material, object, group );

                }

                object.onAfterRender( _this, scene, camera, geometry, material, group );

        }

        function initMaterial( material, scene, object ) {

                if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...

                const materialProperties = properties.get( material );

                const lights = currentRenderState.state.lights;
                const shadowsArray = currentRenderState.state.shadowsArray;

                const lightsStateVersion = lights.state.version;

                const parameters = programCache.getParameters( material, lights.state, shadowsArray, scene, object );
                const programCacheKey = programCache.getProgramCacheKey( parameters );

                let program = materialProperties.program;
                let programChange = true;

                // always update environment and fog - changing these trigger an initMaterial call, but it's possible that the program doesn't change

                materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
                materialProperties.fog = scene.fog;
                materialProperties.envMap = cubemaps.get( material.envMap || materialProperties.environment );

                if ( program === undefined ) {

                        // new material
                        material.addEventListener( 'dispose', onMaterialDispose );

                } else if ( program.cacheKey !== programCacheKey ) {

                        // changed glsl or parameters
                        releaseMaterialProgramReference( material );

                } else if ( materialProperties.lightsStateVersion !== lightsStateVersion ) {

                        programChange = false;

                } else if ( parameters.shaderID !== undefined ) {

                        // same glsl and uniform list
                        return;

                } else {

                        // only rebuild uniform list
                        programChange = false;

                }

                if ( programChange ) {

                        parameters.uniforms = programCache.getUniforms( material );

                        material.onBeforeCompile( parameters, _this );

                        program = programCache.acquireProgram( parameters, programCacheKey );

                        materialProperties.program = program;
                        materialProperties.uniforms = parameters.uniforms;
                        materialProperties.outputEncoding = parameters.outputEncoding;

                }

                const uniforms = materialProperties.uniforms;

                if ( ! material.isShaderMaterial &&
                        ! material.isRawShaderMaterial ||
                        material.clipping === true ) {

                        materialProperties.numClippingPlanes = clipping.numPlanes;
                        materialProperties.numIntersection = clipping.numIntersection;
                        uniforms.clippingPlanes = clipping.uniform;

                }

                // store the light setup it was created for

                materialProperties.needsLights = materialNeedsLights( material );
                materialProperties.lightsStateVersion = lightsStateVersion;

                if ( materialProperties.needsLights ) {

                        // wire up the material to this renderer's lighting state

                        uniforms.ambientLightColor.value = lights.state.ambient;
                        uniforms.lightProbe.value = lights.state.probe;
                        uniforms.directionalLights.value = lights.state.directional;
                        uniforms.directionalLightShadows.value = lights.state.directionalShadow;
                        uniforms.spotLights.value = lights.state.spot;
                        uniforms.spotLightShadows.value = lights.state.spotShadow;
                        uniforms.rectAreaLights.value = lights.state.rectArea;
                        uniforms.ltc_1.value = lights.state.rectAreaLTC1;
                        uniforms.ltc_2.value = lights.state.rectAreaLTC2;
                        uniforms.pointLights.value = lights.state.point;
                        uniforms.pointLightShadows.value = lights.state.pointShadow;
                        uniforms.hemisphereLights.value = lights.state.hemi;

                        uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
                        uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
                        uniforms.spotShadowMap.value = lights.state.spotShadowMap;
                        uniforms.spotShadowMatrix.value = lights.state.spotShadowMatrix;
                        uniforms.pointShadowMap.value = lights.state.pointShadowMap;
                        uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
                        // TODO (abelnation): add area lights shadow info to uniforms

                }

                const progUniforms = materialProperties.program.getUniforms();
                const uniformsList = WebGLUniforms.seqWithValue( progUniforms.seq, uniforms );

                materialProperties.uniformsList = uniformsList;

        }

        function setProgram( camera, scene, material, object ) {

                if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...

                textures.resetTextureUnits();

                const fog = scene.fog;
                const environment = material.isMeshStandardMaterial ? scene.environment : null;
                const encoding = ( _currentRenderTarget === null ) ? _this.outputEncoding : _currentRenderTarget.texture.encoding;
                const envMap = cubemaps.get( material.envMap || environment );

                const materialProperties = properties.get( material );
                const lights = currentRenderState.state.lights;

                if ( _clippingEnabled === true ) {

                        if ( _localClippingEnabled === true || camera !== _currentCamera ) {

                                const useCache =
                                        camera === _currentCamera &&
                                        material.id === _currentMaterialId;

                                // we might want to call this function with some ClippingGroup
                                // object instead of the material, once it becomes feasible
                                // (#8465, #8379)
                                clipping.setState( material, camera, useCache );

                        }

                }

                if ( material.version === materialProperties.__version ) {

                        if ( material.fog && materialProperties.fog !== fog ) {

                                initMaterial( material, scene, object );

                        } else if ( materialProperties.environment !== environment ) {

                                initMaterial( material, scene, object );

                        } else if ( materialProperties.needsLights && ( materialProperties.lightsStateVersion !== lights.state.version ) ) {

                                initMaterial( material, scene, object );

                        } else if ( materialProperties.numClippingPlanes !== undefined &&
                                ( materialProperties.numClippingPlanes !== clipping.numPlanes ||
                                materialProperties.numIntersection !== clipping.numIntersection ) ) {

                                initMaterial( material, scene, object );

                        } else if ( materialProperties.outputEncoding !== encoding ) {

                                initMaterial( material, scene, object );

                        } else if ( materialProperties.envMap !== envMap ) {

                                initMaterial( material, scene, object );

                        }

                } else {

                        initMaterial( material, scene, object );
                        materialProperties.__version = material.version;

                }

                let refreshProgram = false;
                let refreshMaterial = false;
                let refreshLights = false;

                const program = materialProperties.program,
                        p_uniforms = program.getUniforms(),
                        m_uniforms = materialProperties.uniforms;

                if ( state.useProgram( program.program ) ) {

                        refreshProgram = true;
                        refreshMaterial = true;
                        refreshLights = true;

                }

                if ( material.id !== _currentMaterialId ) {

                        _currentMaterialId = material.id;

                        refreshMaterial = true;

                }

                if ( refreshProgram || _currentCamera !== camera ) {

                        p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );

                        if ( capabilities.logarithmicDepthBuffer ) {

                                p_uniforms.setValue( _gl, 'logDepthBufFC',
                                        2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );

                        }

                        if ( _currentCamera !== camera ) {

                                _currentCamera = camera;

                                // lighting uniforms depend on the camera so enforce an update
                                // now, in case this material supports lights - or later, when
                                // the next material that does gets activated:

                                refreshMaterial = true;         // set to true on material change
                                refreshLights = true;           // remains set until update done

                        }

                        // load material specific uniforms
                        // (shader material also gets them for the sake of genericity)

                        if ( material.isShaderMaterial ||
                                material.isMeshPhongMaterial ||
                                material.isMeshToonMaterial ||
                                material.isMeshStandardMaterial ||
                                material.envMap ) {

                                const uCamPos = p_uniforms.map.cameraPosition;

                                if ( uCamPos !== undefined ) {

                                        uCamPos.setValue( _gl,
                                                _vector3.setFromMatrixPosition( camera.matrixWorld ) );

                                }

                        }

                        if ( material.isMeshPhongMaterial ||
                                material.isMeshToonMaterial ||
                                material.isMeshLambertMaterial ||
                                material.isMeshBasicMaterial ||
                                material.isMeshStandardMaterial ||
                                material.isShaderMaterial ) {

                                p_uniforms.setValue( _gl, 'isOrthographic', camera.isOrthographicCamera === true );

                        }

                        if ( material.isMeshPhongMaterial ||
                                material.isMeshToonMaterial ||
                                material.isMeshLambertMaterial ||
                                material.isMeshBasicMaterial ||
                                material.isMeshStandardMaterial ||
                                material.isShaderMaterial ||
                                material.isShadowMaterial ||
                                material.skinning ) {

                                p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );

                        }

                }

                // skinning uniforms must be set even if material didn't change
                // auto-setting of texture unit for bone texture must go before other textures
                // otherwise textures used for skinning can take over texture units reserved for other material textures

                if ( material.skinning ) {

                        p_uniforms.setOptional( _gl, object, 'bindMatrix' );
                        p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );

                        const skeleton = object.skeleton;

                        if ( skeleton ) {

                                const bones = skeleton.bones;

                                if ( capabilities.floatVertexTextures ) {

                                        if ( skeleton.boneTexture === null ) {

                                                // layout (1 matrix = 4 pixels)
                                                //      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
                                                //  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)
                                                //       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)
                                                //       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)
                                                //       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)


                                                let size = Math.sqrt( bones.length * 4 ); // 4 pixels needed for 1 matrix
                                                size = MathUtils.ceilPowerOfTwo( size );
                                                size = Math.max( size, 4 );

                                                const boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel
                                                boneMatrices.set( skeleton.boneMatrices ); // copy current values

                                                const boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType );

                                                skeleton.boneMatrices = boneMatrices;
                                                skeleton.boneTexture = boneTexture;
                                                skeleton.boneTextureSize = size;

                                        }

                                        p_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture, textures );
                                        p_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize );

                                } else {

                                        p_uniforms.setOptional( _gl, skeleton, 'boneMatrices' );

                                }

                        }

                }

                if ( refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow ) {

                        materialProperties.receiveShadow = object.receiveShadow;
                        p_uniforms.setValue( _gl, 'receiveShadow', object.receiveShadow );

                }

                if ( refreshMaterial ) {

                        p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );

                        if ( materialProperties.needsLights ) {

                                // the current material requires lighting info

                                // note: all lighting uniforms are always set correctly
                                // they simply reference the renderer's state for their
                                // values
                                //
                                // use the current material's .needsUpdate flags to set
                                // the GL state when required

                                markUniformsLightsNeedsUpdate( m_uniforms, refreshLights );

                        }

                        // refresh uniforms common to several materials

                        if ( fog && material.fog ) {

                                materials.refreshFogUniforms( m_uniforms, fog );

                        }

                        materials.refreshMaterialUniforms( m_uniforms, material, _pixelRatio, _height );

                        WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );

                }

                if ( material.isShaderMaterial && material.uniformsNeedUpdate === true ) {

                        WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
                        material.uniformsNeedUpdate = false;

                }

                if ( material.isSpriteMaterial ) {

                        p_uniforms.setValue( _gl, 'center', object.center );

                }

                // common matrices

                p_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );
                p_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );
                p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );

                return program;

        }

        // If uniforms are marked as clean, they don't need to be loaded to the GPU.

        function markUniformsLightsNeedsUpdate( uniforms, value ) {

                uniforms.ambientLightColor.needsUpdate = value;
                uniforms.lightProbe.needsUpdate = value;

                uniforms.directionalLights.needsUpdate = value;
                uniforms.directionalLightShadows.needsUpdate = value;
                uniforms.pointLights.needsUpdate = value;
                uniforms.pointLightShadows.needsUpdate = value;
                uniforms.spotLights.needsUpdate = value;
                uniforms.spotLightShadows.needsUpdate = value;
                uniforms.rectAreaLights.needsUpdate = value;
                uniforms.hemisphereLights.needsUpdate = value;

        }

        function materialNeedsLights( material ) {

                return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial ||
                        material.isMeshStandardMaterial || material.isShadowMaterial ||
                        ( material.isShaderMaterial && material.lights === true );

        }

        //
        this.setFramebuffer = function ( value ) {

                if ( _framebuffer !== value && _currentRenderTarget === null ) _gl.bindFramebuffer( 36160, value );

                _framebuffer = value;

        };

        this.getActiveCubeFace = function () {

                return _currentActiveCubeFace;

        };

        this.getActiveMipmapLevel = function () {

                return _currentActiveMipmapLevel;

        };

        this.getRenderList = function () {

                return currentRenderList;

        };

        this.setRenderList = function ( renderList ) {

                currentRenderList = renderList;

        };

        this.getRenderTarget = function () {

                return _currentRenderTarget;

        };

        this.setRenderTarget = function ( renderTarget, activeCubeFace = 0, activeMipmapLevel = 0 ) {

                _currentRenderTarget = renderTarget;
                _currentActiveCubeFace = activeCubeFace;
                _currentActiveMipmapLevel = activeMipmapLevel;

                if ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) {

                        textures.setupRenderTarget( renderTarget );

                }

                let framebuffer = _framebuffer;
                let isCube = false;

                if ( renderTarget ) {

                        const __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;

                        if ( renderTarget.isWebGLCubeRenderTarget ) {

                                framebuffer = __webglFramebuffer[ activeCubeFace ];
                                isCube = true;

                        } else if ( renderTarget.isWebGLMultisampleRenderTarget ) {

                                framebuffer = properties.get( renderTarget ).__webglMultisampledFramebuffer;

                        } else {

                                framebuffer = __webglFramebuffer;

                        }

                        _currentViewport.copy( renderTarget.viewport );
                        _currentScissor.copy( renderTarget.scissor );
                        _currentScissorTest = renderTarget.scissorTest;

                } else {

                        _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor();
                        _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor();
                        _currentScissorTest = _scissorTest;

                }

                if ( _currentFramebuffer !== framebuffer ) {

                        _gl.bindFramebuffer( 36160, framebuffer );
                        _currentFramebuffer = framebuffer;

                }

                state.viewport( _currentViewport );
                state.scissor( _currentScissor );
                state.setScissorTest( _currentScissorTest );

                if ( isCube ) {

                        const textureProperties = properties.get( renderTarget.texture );
                        _gl.framebufferTexture2D( 36160, 36064, 34069 + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel );

                }

        };

        this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {

                if ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {

                        console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
                        return;

                }

                let framebuffer = properties.get( renderTarget ).__webglFramebuffer;

                if ( renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined ) {

                        framebuffer = framebuffer[ activeCubeFaceIndex ];

                }

                if ( framebuffer ) {

                        let restore = false;

                        if ( framebuffer !== _currentFramebuffer ) {

                                _gl.bindFramebuffer( 36160, framebuffer );

                                restore = true;

                        }

                        try {

                                const texture = renderTarget.texture;
                                const textureFormat = texture.format;
                                const textureType = texture.type;

                                if ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( 35739 ) ) {

                                        console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
                                        return;

                                }

                                const halfFloatSupportedByExt = ( textureType === HalfFloatType ) && ( extensions.has( 'EXT_color_buffer_half_float' ) || ( capabilities.isWebGL2 && extensions.has( 'EXT_color_buffer_float' ) ) );

                                if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( 35738 ) && // IE11, Edge and Chrome Mac < 52 (#9513)
                                        ! ( textureType === FloatType && ( capabilities.isWebGL2 || extensions.has( 'OES_texture_float' ) || extensions.has( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox
                                        ! halfFloatSupportedByExt ) {

                                        console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );
                                        return;

                                }

                                if ( _gl.checkFramebufferStatus( 36160 ) === 36053 ) {

                                        // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)

                                        if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {

                                                _gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );

                                        }

                                } else {

                                        console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' );

                                }

                        } finally {

                                if ( restore ) {

                                        _gl.bindFramebuffer( 36160, _currentFramebuffer );

                                }

                        }

                }

        };

        this.copyFramebufferToTexture = function ( position, texture, level = 0 ) {

                const levelScale = Math.pow( 2, - level );
                const width = Math.floor( texture.image.width * levelScale );
                const height = Math.floor( texture.image.height * levelScale );
                const glFormat = utils.convert( texture.format );

                textures.setTexture2D( texture, 0 );

                _gl.copyTexImage2D( 3553, level, glFormat, position.x, position.y, width, height, 0 );

                state.unbindTexture();

        };

        this.copyTextureToTexture = function ( position, srcTexture, dstTexture, level = 0 ) {

                const width = srcTexture.image.width;
                const height = srcTexture.image.height;
                const glFormat = utils.convert( dstTexture.format );
                const glType = utils.convert( dstTexture.type );

                textures.setTexture2D( dstTexture, 0 );

                // As another texture upload may have changed pixelStorei
                // parameters, make sure they are correct for the dstTexture
                _gl.pixelStorei( 37440, dstTexture.flipY );
                _gl.pixelStorei( 37441, dstTexture.premultiplyAlpha );
                _gl.pixelStorei( 3317, dstTexture.unpackAlignment );

                if ( srcTexture.isDataTexture ) {

                        _gl.texSubImage2D( 3553, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data );

                } else {

                        if ( srcTexture.isCompressedTexture ) {

                                _gl.compressedTexSubImage2D( 3553, level, position.x, position.y, srcTexture.mipmaps[ 0 ].width, srcTexture.mipmaps[ 0 ].height, glFormat, srcTexture.mipmaps[ 0 ].data );

                        } else {

                                _gl.texSubImage2D( 3553, level, position.x, position.y, glFormat, glType, srcTexture.image );

                        }

                }

                // Generate mipmaps only when copying level 0
                if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( 3553 );

                state.unbindTexture();

        };

        this.initTexture = function ( texture ) {

                textures.setTexture2D( texture, 0 );

                state.unbindTexture();

        };

        this.resetState = function () {

                state.reset();
                bindingStates.reset();

        };

        if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {

                __THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) ); // eslint-disable-line no-undef

        }

    }

    function WebGL1Renderer( parameters ) {

        WebGLRenderer.call( this, parameters );

    }

    WebGL1Renderer.prototype = Object.assign( Object.create( WebGLRenderer.prototype ), {

        constructor: WebGL1Renderer,

        isWebGL1Renderer: true

    } );

    class Scene extends Object3D {

        constructor() {

                super();

                Object.defineProperty( this, 'isScene', { value: true } );

                this.type = 'Scene';

                this.background = null;
                this.environment = null;
                this.fog = null;

                this.overrideMaterial = null;

                this.autoUpdate = true; // checked by the renderer

                if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {

                        __THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) ); // eslint-disable-line no-undef

                }

        }

        copy( source, recursive ) {

                super.copy( source, recursive );

                if ( source.background !== null ) this.background = source.background.clone();
                if ( source.environment !== null ) this.environment = source.environment.clone();
                if ( source.fog !== null ) this.fog = source.fog.clone();

                if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();

                this.autoUpdate = source.autoUpdate;
                this.matrixAutoUpdate = source.matrixAutoUpdate;

                return this;

        }

        toJSON( meta ) {

                const data = super.toJSON( meta );

                if ( this.background !== null ) data.object.background = this.background.toJSON( meta );
                if ( this.environment !== null ) data.object.environment = this.environment.toJSON( meta );
                if ( this.fog !== null ) data.object.fog = this.fog.toJSON();

                return data;

        }

    }

    function InterleavedBuffer( array, stride ) {

        this.array = array;
        this.stride = stride;
        this.count = array !== undefined ? array.length / stride : 0;

        this.usage = StaticDrawUsage;
        this.updateRange = { offset: 0, count: - 1 };

        this.version = 0;

        this.uuid = MathUtils.generateUUID();

    }

    Object.defineProperty( InterleavedBuffer.prototype, 'needsUpdate', {

        set: function ( value ) {

                if ( value === true ) this.version ++;

        }

    } );

    Object.assign( InterleavedBuffer.prototype, {

        isInterleavedBuffer: true,

        onUploadCallback: function () {},

        setUsage: function ( value ) {

                this.usage = value;

                return this;

        },

        copy: function ( source ) {

                this.array = new source.array.constructor( source.array );
                this.count = source.count;
                this.stride = source.stride;
                this.usage = source.usage;

                return this;

        },

        copyAt: function ( index1, attribute, index2 ) {

                index1 *= this.stride;
                index2 *= attribute.stride;

                for ( let i = 0, l = this.stride; i < l; i ++ ) {

                        this.array[ index1 + i ] = attribute.array[ index2 + i ];

                }

                return this;

        },

        set: function ( value, offset = 0 ) {

                this.array.set( value, offset );

                return this;

        },

        clone: function ( data ) {

                if ( data.arrayBuffers === undefined ) {

                        data.arrayBuffers = {};

                }

                if ( this.array.buffer._uuid === undefined ) {

                        this.array.buffer._uuid = MathUtils.generateUUID();

                }

                if ( data.arrayBuffers[ this.array.buffer._uuid ] === undefined ) {

                        data.arrayBuffers[ this.array.buffer._uuid ] = this.array.slice( 0 ).buffer;

                }

                const array = new this.array.constructor( data.arrayBuffers[ this.array.buffer._uuid ] );

                const ib = new InterleavedBuffer( array, this.stride );
                ib.setUsage( this.usage );

                return ib;

        },

        onUpload: function ( callback ) {

                this.onUploadCallback = callback;

                return this;

        },

        toJSON: function ( data ) {

                if ( data.arrayBuffers === undefined ) {

                        data.arrayBuffers = {};

                }

                // generate UUID for array buffer if necessary

                if ( this.array.buffer._uuid === undefined ) {

                        this.array.buffer._uuid = MathUtils.generateUUID();

                }

                if ( data.arrayBuffers[ this.array.buffer._uuid ] === undefined ) {

                        data.arrayBuffers[ this.array.buffer._uuid ] = Array.prototype.slice.call( new Uint32Array( this.array.buffer ) );

                }

                //

                return {
                        uuid: this.uuid,
                        buffer: this.array.buffer._uuid,
                        type: this.array.constructor.name,
                        stride: this.stride
                };

        }

    } );

    const _vector$6 = new Vector3();

    function InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, normalized ) {

        this.name = '';

        this.data = interleavedBuffer;
        this.itemSize = itemSize;
        this.offset = offset;

        this.normalized = normalized === true;

    }

    Object.defineProperties( InterleavedBufferAttribute.prototype, {

        count: {

                get: function () {

                        return this.data.count;

                }

        },

        array: {

                get: function () {

                        return this.data.array;

                }

        },

        needsUpdate: {

                set: function ( value ) {

                        this.data.needsUpdate = value;

                }

        }

    } );

    Object.assign( InterleavedBufferAttribute.prototype, {

        isInterleavedBufferAttribute: true,

        applyMatrix4: function ( m ) {

                for ( let i = 0, l = this.data.count; i < l; i ++ ) {

                        _vector$6.x = this.getX( i );
                        _vector$6.y = this.getY( i );
                        _vector$6.z = this.getZ( i );

                        _vector$6.applyMatrix4( m );

                        this.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );

                }

                return this;

        },

        setX: function ( index, x ) {

                this.data.array[ index * this.data.stride + this.offset ] = x;

                return this;

        },

        setY: function ( index, y ) {

                this.data.array[ index * this.data.stride + this.offset + 1 ] = y;

                return this;

        },

        setZ: function ( index, z ) {

                this.data.array[ index * this.data.stride + this.offset + 2 ] = z;

                return this;

        },

        setW: function ( index, w ) {

                this.data.array[ index * this.data.stride + this.offset + 3 ] = w;

                return this;

        },

        getX: function ( index ) {

                return this.data.array[ index * this.data.stride + this.offset ];

        },

        getY: function ( index ) {

                return this.data.array[ index * this.data.stride + this.offset + 1 ];

        },

        getZ: function ( index ) {

                return this.data.array[ index * this.data.stride + this.offset + 2 ];

        },

        getW: function ( index ) {

                return this.data.array[ index * this.data.stride + this.offset + 3 ];

        },

        setXY: function ( index, x, y ) {

                index = index * this.data.stride + this.offset;

                this.data.array[ index + 0 ] = x;
                this.data.array[ index + 1 ] = y;

                return this;

        },

        setXYZ: function ( index, x, y, z ) {

                index = index * this.data.stride + this.offset;

                this.data.array[ index + 0 ] = x;
                this.data.array[ index + 1 ] = y;
                this.data.array[ index + 2 ] = z;

                return this;

        },

        setXYZW: function ( index, x, y, z, w ) {

                index = index * this.data.stride + this.offset;

                this.data.array[ index + 0 ] = x;
                this.data.array[ index + 1 ] = y;
                this.data.array[ index + 2 ] = z;
                this.data.array[ index + 3 ] = w;

                return this;

        },

        clone: function ( data ) {

                if ( data === undefined ) {

                        console.log( 'THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.' );

                        const array = [];

                        for ( let i = 0; i < this.count; i ++ ) {

                                const index = i * this.data.stride + this.offset;

                                for ( let j = 0; j < this.itemSize; j ++ ) {

                                        array.push( this.data.array[ index + j ] );

                                }

                        }

                        return new BufferAttribute( new this.array.constructor( array ), this.itemSize, this.normalized );

                } else {

                        if ( data.interleavedBuffers === undefined ) {

                                data.interleavedBuffers = {};

                        }

                        if ( data.interleavedBuffers[ this.data.uuid ] === undefined ) {

                                data.interleavedBuffers[ this.data.uuid ] = this.data.clone( data );

                        }

                        return new InterleavedBufferAttribute( data.interleavedBuffers[ this.data.uuid ], this.itemSize, this.offset, this.normalized );

                }

        },

        toJSON: function ( data ) {

                if ( data === undefined ) {

                        console.log( 'THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.' );

                        const array = [];

                        for ( let i = 0; i < this.count; i ++ ) {

                                const index = i * this.data.stride + this.offset;

                                for ( let j = 0; j < this.itemSize; j ++ ) {

                                        array.push( this.data.array[ index + j ] );

                                }

                        }

                        // deinterleave data and save it as an ordinary buffer attribute for now

                        return {
                                itemSize: this.itemSize,
                                type: this.array.constructor.name,
                                array: array,
                                normalized: this.normalized
                        };

                } else {

                        // save as true interlaved attribtue

                        if ( data.interleavedBuffers === undefined ) {

                                data.interleavedBuffers = {};

                        }

                        if ( data.interleavedBuffers[ this.data.uuid ] === undefined ) {

                                data.interleavedBuffers[ this.data.uuid ] = this.data.toJSON( data );

                        }

                        return {
                                isInterleavedBufferAttribute: true,
                                itemSize: this.itemSize,
                                data: this.data.uuid,
                                offset: this.offset,
                                normalized: this.normalized
                        };

                }

        }

    } );

    /**
     * parameters = {
     *  color: <hex>,
     *  map: new THREE.Texture( <Image> ),
     *  alphaMap: new THREE.Texture( <Image> ),
     *  rotation: <float>,
     *  sizeAttenuation: <bool>
     * }
     */

    function SpriteMaterial( parameters ) {

        Material.call( this );

        this.type = 'SpriteMaterial';

        this.color = new Color( 0xffffff );

        this.map = null;

        this.alphaMap = null;

        this.rotation = 0;

        this.sizeAttenuation = true;

        this.transparent = true;

        this.setValues( parameters );

    }

    SpriteMaterial.prototype = Object.create( Material.prototype );
    SpriteMaterial.prototype.constructor = SpriteMaterial;
    SpriteMaterial.prototype.isSpriteMaterial = true;

    SpriteMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        this.map = source.map;

        this.alphaMap = source.alphaMap;

        this.rotation = source.rotation;

        this.sizeAttenuation = source.sizeAttenuation;

        return this;

    };

    let _geometry;

    const _intersectPoint = new Vector3();
    const _worldScale = new Vector3();
    const _mvPosition = new Vector3();

    const _alignedPosition = new Vector2();
    const _rotatedPosition = new Vector2();
    const _viewWorldMatrix = new Matrix4();

    const _vA$1 = new Vector3();
    const _vB$1 = new Vector3();
    const _vC$1 = new Vector3();

    const _uvA$1 = new Vector2();
    const _uvB$1 = new Vector2();
    const _uvC$1 = new Vector2();

    function Sprite( material ) {

        Object3D.call( this );

        this.type = 'Sprite';

        if ( _geometry === undefined ) {

                _geometry = new BufferGeometry();

                const float32Array = new Float32Array( [
                        - 0.5, - 0.5, 0, 0, 0,
                        0.5, - 0.5, 0, 1, 0,
                        0.5, 0.5, 0, 1, 1,
                        - 0.5, 0.5, 0, 0, 1
                ] );

                const interleavedBuffer = new InterleavedBuffer( float32Array, 5 );

                _geometry.setIndex( [ 0, 1, 2,  0, 2, 3 ] );
                _geometry.setAttribute( 'position', new InterleavedBufferAttribute( interleavedBuffer, 3, 0, false ) );
                _geometry.setAttribute( 'uv', new InterleavedBufferAttribute( interleavedBuffer, 2, 3, false ) );

        }

        this.geometry = _geometry;
        this.material = ( material !== undefined ) ? material : new SpriteMaterial();

        this.center = new Vector2( 0.5, 0.5 );

    }

    Sprite.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Sprite,

        isSprite: true,

        raycast: function ( raycaster, intersects ) {

                if ( raycaster.camera === null ) {

                        console.error( 'THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.' );

                }

                _worldScale.setFromMatrixScale( this.matrixWorld );

                _viewWorldMatrix.copy( raycaster.camera.matrixWorld );
                this.modelViewMatrix.multiplyMatrices( raycaster.camera.matrixWorldInverse, this.matrixWorld );

                _mvPosition.setFromMatrixPosition( this.modelViewMatrix );

                if ( raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false ) {

                        _worldScale.multiplyScalar( - _mvPosition.z );

                }

                const rotation = this.material.rotation;
                let sin, cos;

                if ( rotation !== 0 ) {

                        cos = Math.cos( rotation );
                        sin = Math.sin( rotation );

                }

                const center = this.center;

                transformVertex( _vA$1.set( - 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
                transformVertex( _vB$1.set( 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
                transformVertex( _vC$1.set( 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );

                _uvA$1.set( 0, 0 );
                _uvB$1.set( 1, 0 );
                _uvC$1.set( 1, 1 );

                // check first triangle
                let intersect = raycaster.ray.intersectTriangle( _vA$1, _vB$1, _vC$1, false, _intersectPoint );

                if ( intersect === null ) {

                        // check second triangle
                        transformVertex( _vB$1.set( - 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
                        _uvB$1.set( 0, 1 );

                        intersect = raycaster.ray.intersectTriangle( _vA$1, _vC$1, _vB$1, false, _intersectPoint );
                        if ( intersect === null ) {

                                return;

                        }

                }

                const distance = raycaster.ray.origin.distanceTo( _intersectPoint );

                if ( distance < raycaster.near || distance > raycaster.far ) return;

                intersects.push( {

                        distance: distance,
                        point: _intersectPoint.clone(),
                        uv: Triangle.getUV( _intersectPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() ),
                        face: null,
                        object: this

                } );

        },

        copy: function ( source ) {

                Object3D.prototype.copy.call( this, source );

                if ( source.center !== undefined ) this.center.copy( source.center );

                this.material = source.material;

                return this;

        }

    } );

    function transformVertex( vertexPosition, mvPosition, center, scale, sin, cos ) {

        // compute position in camera space
        _alignedPosition.subVectors( vertexPosition, center ).addScalar( 0.5 ).multiply( scale );

        // to check if rotation is not zero
        if ( sin !== undefined ) {

                _rotatedPosition.x = ( cos * _alignedPosition.x ) - ( sin * _alignedPosition.y );
                _rotatedPosition.y = ( sin * _alignedPosition.x ) + ( cos * _alignedPosition.y );

        } else {

                _rotatedPosition.copy( _alignedPosition );

        }


        vertexPosition.copy( mvPosition );
        vertexPosition.x += _rotatedPosition.x;
        vertexPosition.y += _rotatedPosition.y;

        // transform to world space
        vertexPosition.applyMatrix4( _viewWorldMatrix );

    }

    const _v1$4 = new Vector3();
    const _v2$2 = new Vector3();

    function LOD() {

        Object3D.call( this );

        this._currentLevel = 0;

        this.type = 'LOD';

        Object.defineProperties( this, {
                levels: {
                        enumerable: true,
                        value: []
                }
        } );

        this.autoUpdate = true;

    }

    LOD.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: LOD,

        isLOD: true,

        copy: function ( source ) {

                Object3D.prototype.copy.call( this, source, false );

                const levels = source.levels;

                for ( let i = 0, l = levels.length; i < l; i ++ ) {

                        const level = levels[ i ];

                        this.addLevel( level.object.clone(), level.distance );

                }

                this.autoUpdate = source.autoUpdate;

                return this;

        },

        addLevel: function ( object, distance = 0 ) {

                distance = Math.abs( distance );

                const levels = this.levels;

                let l;

                for ( l = 0; l < levels.length; l ++ ) {

                        if ( distance < levels[ l ].distance ) {

                                break;

                        }

                }

                levels.splice( l, 0, { distance: distance, object: object } );

                this.add( object );

                return this;

        },

        getCurrentLevel: function () {

                return this._currentLevel;

        },

        getObjectForDistance: function ( distance ) {

                const levels = this.levels;

                if ( levels.length > 0 ) {

                        let i, l;

                        for ( i = 1, l = levels.length; i < l; i ++ ) {

                                if ( distance < levels[ i ].distance ) {

                                        break;

                                }

                        }

                        return levels[ i - 1 ].object;

                }

                return null;

        },

        raycast: function ( raycaster, intersects ) {

                const levels = this.levels;

                if ( levels.length > 0 ) {

                        _v1$4.setFromMatrixPosition( this.matrixWorld );

                        const distance = raycaster.ray.origin.distanceTo( _v1$4 );

                        this.getObjectForDistance( distance ).raycast( raycaster, intersects );

                }

        },

        update: function ( camera ) {

                const levels = this.levels;

                if ( levels.length > 1 ) {

                        _v1$4.setFromMatrixPosition( camera.matrixWorld );
                        _v2$2.setFromMatrixPosition( this.matrixWorld );

                        const distance = _v1$4.distanceTo( _v2$2 ) / camera.zoom;

                        levels[ 0 ].object.visible = true;

                        let i, l;

                        for ( i = 1, l = levels.length; i < l; i ++ ) {

                                if ( distance >= levels[ i ].distance ) {

                                        levels[ i - 1 ].object.visible = false;
                                        levels[ i ].object.visible = true;

                                } else {

                                        break;

                                }

                        }

                        this._currentLevel = i - 1;

                        for ( ; i < l; i ++ ) {

                                levels[ i ].object.visible = false;

                        }

                }

        },

        toJSON: function ( meta ) {

                const data = Object3D.prototype.toJSON.call( this, meta );

                if ( this.autoUpdate === false ) data.object.autoUpdate = false;

                data.object.levels = [];

                const levels = this.levels;

                for ( let i = 0, l = levels.length; i < l; i ++ ) {

                        const level = levels[ i ];

                        data.object.levels.push( {
                                object: level.object.uuid,
                                distance: level.distance
                        } );

                }

                return data;

        }

    } );

    const _basePosition = new Vector3();

    const _skinIndex = new Vector4();
    const _skinWeight = new Vector4();

    const _vector$7 = new Vector3();
    const _matrix$1 = new Matrix4();

    function SkinnedMesh( geometry, material ) {

        if ( geometry && geometry.isGeometry ) {

                console.error( 'THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

        }

        Mesh.call( this, geometry, material );

        this.type = 'SkinnedMesh';

        this.bindMode = 'attached';
        this.bindMatrix = new Matrix4();
        this.bindMatrixInverse = new Matrix4();

    }

    SkinnedMesh.prototype = Object.assign( Object.create( Mesh.prototype ), {

        constructor: SkinnedMesh,

        isSkinnedMesh: true,

        copy: function ( source ) {

                Mesh.prototype.copy.call( this, source );

                this.bindMode = source.bindMode;
                this.bindMatrix.copy( source.bindMatrix );
                this.bindMatrixInverse.copy( source.bindMatrixInverse );

                this.skeleton = source.skeleton;

                return this;

        },

        bind: function ( skeleton, bindMatrix ) {

                this.skeleton = skeleton;

                if ( bindMatrix === undefined ) {

                        this.updateMatrixWorld( true );

                        this.skeleton.calculateInverses();

                        bindMatrix = this.matrixWorld;

                }

                this.bindMatrix.copy( bindMatrix );
                this.bindMatrixInverse.copy( bindMatrix ).invert();

        },

        pose: function () {

                this.skeleton.pose();

        },

        normalizeSkinWeights: function () {

                const vector = new Vector4();

                const skinWeight = this.geometry.attributes.skinWeight;

                for ( let i = 0, l = skinWeight.count; i < l; i ++ ) {

                        vector.x = skinWeight.getX( i );
                        vector.y = skinWeight.getY( i );
                        vector.z = skinWeight.getZ( i );
                        vector.w = skinWeight.getW( i );

                        const scale = 1.0 / vector.manhattanLength();

                        if ( scale !== Infinity ) {

                                vector.multiplyScalar( scale );

                        } else {

                                vector.set( 1, 0, 0, 0 ); // do something reasonable

                        }

                        skinWeight.setXYZW( i, vector.x, vector.y, vector.z, vector.w );

                }

        },

        updateMatrixWorld: function ( force ) {

                Mesh.prototype.updateMatrixWorld.call( this, force );

                if ( this.bindMode === 'attached' ) {

                        this.bindMatrixInverse.copy( this.matrixWorld ).invert();

                } else if ( this.bindMode === 'detached' ) {

                        this.bindMatrixInverse.copy( this.bindMatrix ).invert();

                } else {

                        console.warn( 'THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode );

                }

        },

        boneTransform: function ( index, target ) {

                const skeleton = this.skeleton;
                const geometry = this.geometry;

                _skinIndex.fromBufferAttribute( geometry.attributes.skinIndex, index );
                _skinWeight.fromBufferAttribute( geometry.attributes.skinWeight, index );

                _basePosition.fromBufferAttribute( geometry.attributes.position, index ).applyMatrix4( this.bindMatrix );

                target.set( 0, 0, 0 );

                for ( let i = 0; i < 4; i ++ ) {

                        const weight = _skinWeight.getComponent( i );

                        if ( weight !== 0 ) {

                                const boneIndex = _skinIndex.getComponent( i );

                                _matrix$1.multiplyMatrices( skeleton.bones[ boneIndex ].matrixWorld, skeleton.boneInverses[ boneIndex ] );

                                target.addScaledVector( _vector$7.copy( _basePosition ).applyMatrix4( _matrix$1 ), weight );

                        }

                }

                return target.applyMatrix4( this.bindMatrixInverse );

        }

    } );

    function Bone() {

        Object3D.call( this );

        this.type = 'Bone';

    }

    Bone.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Bone,

        isBone: true

    } );

    const _offsetMatrix = new Matrix4();
    const _identityMatrix = new Matrix4();

    function Skeleton( bones = [], boneInverses = [] ) {

        this.uuid = MathUtils.generateUUID();

        this.bones = bones.slice( 0 );
        this.boneInverses = boneInverses;
        this.boneMatrices = null;

        this.boneTexture = null;
        this.boneTextureSize = 0;

        this.frame = - 1;

        this.init();

    }

    Object.assign( Skeleton.prototype, {

        init: function () {

                const bones = this.bones;
                const boneInverses = this.boneInverses;

                this.boneMatrices = new Float32Array( bones.length * 16 );

                // calculate inverse bone matrices if necessary

                if ( boneInverses.length === 0 ) {

                        this.calculateInverses();

                } else {

                        // handle special case

                        if ( bones.length !== boneInverses.length ) {

                                console.warn( 'THREE.Skeleton: Number of inverse bone matrices does not match amount of bones.' );

                                this.boneInverses = [];

                                for ( let i = 0, il = this.bones.length; i < il; i ++ ) {

                                        this.boneInverses.push( new Matrix4() );

                                }

                        }

                }

        },

        calculateInverses: function () {

                this.boneInverses.length = 0;

                for ( let i = 0, il = this.bones.length; i < il; i ++ ) {

                        const inverse = new Matrix4();

                        if ( this.bones[ i ] ) {

                                inverse.copy( this.bones[ i ].matrixWorld ).invert();

                        }

                        this.boneInverses.push( inverse );

                }

        },

        pose: function () {

                // recover the bind-time world matrices

                for ( let i = 0, il = this.bones.length; i < il; i ++ ) {

                        const bone = this.bones[ i ];

                        if ( bone ) {

                                bone.matrixWorld.copy( this.boneInverses[ i ] ).invert();

                        }

                }

                // compute the local matrices, positions, rotations and scales

                for ( let i = 0, il = this.bones.length; i < il; i ++ ) {

                        const bone = this.bones[ i ];

                        if ( bone ) {

                                if ( bone.parent && bone.parent.isBone ) {

                                        bone.matrix.copy( bone.parent.matrixWorld ).invert();
                                        bone.matrix.multiply( bone.matrixWorld );

                                } else {

                                        bone.matrix.copy( bone.matrixWorld );

                                }

                                bone.matrix.decompose( bone.position, bone.quaternion, bone.scale );

                        }

                }

        },

        update: function () {

                const bones = this.bones;
                const boneInverses = this.boneInverses;
                const boneMatrices = this.boneMatrices;
                const boneTexture = this.boneTexture;

                // flatten bone matrices to array

                for ( let i = 0, il = bones.length; i < il; i ++ ) {

                        // compute the offset between the current and the original transform

                        const matrix = bones[ i ] ? bones[ i ].matrixWorld : _identityMatrix;

                        _offsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] );
                        _offsetMatrix.toArray( boneMatrices, i * 16 );

                }

                if ( boneTexture !== null ) {

                        boneTexture.needsUpdate = true;

                }

        },

        clone: function () {

                return new Skeleton( this.bones, this.boneInverses );

        },

        getBoneByName: function ( name ) {

                for ( let i = 0, il = this.bones.length; i < il; i ++ ) {

                        const bone = this.bones[ i ];

                        if ( bone.name === name ) {

                                return bone;

                        }

                }

                return undefined;

        },

        dispose: function ( ) {

                if ( this.boneTexture !== null ) {

                        this.boneTexture.dispose();

                        this.boneTexture = null;

                }

        },

        fromJSON: function ( json, bones ) {

                this.uuid = json.uuid;

                for ( let i = 0, l = json.bones.length; i < l; i ++ ) {

                        const uuid = json.bones[ i ];
                        let bone = bones[ uuid ];

                        if ( bone === undefined ) {

                                console.warn( 'THREE.Skeleton: No bone found with UUID:', uuid );
                                bone = new Bone();

                        }

                        this.bones.push( bone );
                        this.boneInverses.push( new Matrix4().fromArray( json.boneInverses[ i ] ) );

                }

                this.init();

                return this;

        },

        toJSON: function () {

                const data = {
                        metadata: {
                                version: 4.5,
                                type: 'Skeleton',
                                generator: 'Skeleton.toJSON'
                        },
                        bones: [],
                        boneInverses: []
                };

                data.uuid = this.uuid;

                const bones = this.bones;
                const boneInverses = this.boneInverses;

                for ( let i = 0, l = bones.length; i < l; i ++ ) {

                        const bone = bones[ i ];
                        data.bones.push( bone.uuid );

                        const boneInverse = boneInverses[ i ];
                        data.boneInverses.push( boneInverse.toArray() );

                }

                return data;

        }

    } );

    const _instanceLocalMatrix = new Matrix4();
    const _instanceWorldMatrix = new Matrix4();

    const _instanceIntersects = [];

    const _mesh = new Mesh();

    function InstancedMesh( geometry, material, count ) {

        Mesh.call( this, geometry, material );

        this.instanceMatrix = new BufferAttribute( new Float32Array( count * 16 ), 16 );
        this.instanceColor = null;

        this.count = count;

        this.frustumCulled = false;

    }

    InstancedMesh.prototype = Object.assign( Object.create( Mesh.prototype ), {

        constructor: InstancedMesh,

        isInstancedMesh: true,

        copy: function ( source ) {

                Mesh.prototype.copy.call( this, source );

                this.instanceMatrix.copy( source.instanceMatrix );

                if ( source.instanceColor !== null ) this.instanceColor = source.instanceColor.clone();

                this.count = source.count;

                return this;

        },

        getColorAt: function ( index, color ) {

                color.fromArray( this.instanceColor.array, index * 3 );

        },

        getMatrixAt: function ( index, matrix ) {

                matrix.fromArray( this.instanceMatrix.array, index * 16 );

        },

        raycast: function ( raycaster, intersects ) {

                const matrixWorld = this.matrixWorld;
                const raycastTimes = this.count;

                _mesh.geometry = this.geometry;
                _mesh.material = this.material;

                if ( _mesh.material === undefined ) return;

                for ( let instanceId = 0; instanceId < raycastTimes; instanceId ++ ) {

                        // calculate the world matrix for each instance

                        this.getMatrixAt( instanceId, _instanceLocalMatrix );

                        _instanceWorldMatrix.multiplyMatrices( matrixWorld, _instanceLocalMatrix );

                        // the mesh represents this single instance

                        _mesh.matrixWorld = _instanceWorldMatrix;

                        _mesh.raycast( raycaster, _instanceIntersects );

                        // process the result of raycast

                        for ( let i = 0, l = _instanceIntersects.length; i < l; i ++ ) {

                                const intersect = _instanceIntersects[ i ];
                                intersect.instanceId = instanceId;
                                intersect.object = this;
                                intersects.push( intersect );

                        }

                        _instanceIntersects.length = 0;

                }

        },

        setColorAt: function ( index, color ) {

                if ( this.instanceColor === null ) {

                        this.instanceColor = new BufferAttribute( new Float32Array( this.count * 3 ), 3 );

                }

                color.toArray( this.instanceColor.array, index * 3 );

        },

        setMatrixAt: function ( index, matrix ) {

                matrix.toArray( this.instanceMatrix.array, index * 16 );

        },

        updateMorphTargets: function () {

        },

        dispose: function () {

                this.dispatchEvent( { type: 'dispose' } );

        }

    } );

    /**
     * parameters = {
     *  color: <hex>,
     *  opacity: <float>,
     *
     *  linewidth: <float>,
     *  linecap: "round",
     *  linejoin: "round"
     * }
     */

    function LineBasicMaterial( parameters ) {

        Material.call( this );

        this.type = 'LineBasicMaterial';

        this.color = new Color( 0xffffff );

        this.linewidth = 1;
        this.linecap = 'round';
        this.linejoin = 'round';

        this.morphTargets = false;

        this.setValues( parameters );

    }

    LineBasicMaterial.prototype = Object.create( Material.prototype );
    LineBasicMaterial.prototype.constructor = LineBasicMaterial;

    LineBasicMaterial.prototype.isLineBasicMaterial = true;

    LineBasicMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        this.linewidth = source.linewidth;
        this.linecap = source.linecap;
        this.linejoin = source.linejoin;

        this.morphTargets = source.morphTargets;

        return this;

    };

    const _start = new Vector3();
    const _end = new Vector3();
    const _inverseMatrix$1 = new Matrix4();
    const _ray$1 = new Ray();
    const _sphere$2 = new Sphere();

    function Line( geometry = new BufferGeometry(), material = new LineBasicMaterial() ) {

        Object3D.call( this );

        this.type = 'Line';

        this.geometry = geometry;
        this.material = material;

        this.updateMorphTargets();

    }

    Line.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Line,

        isLine: true,

        copy: function ( source ) {

                Object3D.prototype.copy.call( this, source );

                this.material = source.material;
                this.geometry = source.geometry;

                return this;

        },

        computeLineDistances: function () {

                const geometry = this.geometry;

                if ( geometry.isBufferGeometry ) {

                        // we assume non-indexed geometry

                        if ( geometry.index === null ) {

                                const positionAttribute = geometry.attributes.position;
                                const lineDistances = [ 0 ];

                                for ( let i = 1, l = positionAttribute.count; i < l; i ++ ) {

                                        _start.fromBufferAttribute( positionAttribute, i - 1 );
                                        _end.fromBufferAttribute( positionAttribute, i );

                                        lineDistances[ i ] = lineDistances[ i - 1 ];
                                        lineDistances[ i ] += _start.distanceTo( _end );

                                }

                                geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );

                        } else {

                                console.warn( 'THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );

                        }

                } else if ( geometry.isGeometry ) {

                        console.error( 'THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

                }

                return this;

        },

        raycast: function ( raycaster, intersects ) {

                const geometry = this.geometry;
                const matrixWorld = this.matrixWorld;
                const threshold = raycaster.params.Line.threshold;

                // Checking boundingSphere distance to ray

                if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();

                _sphere$2.copy( geometry.boundingSphere );
                _sphere$2.applyMatrix4( matrixWorld );
                _sphere$2.radius += threshold;

                if ( raycaster.ray.intersectsSphere( _sphere$2 ) === false ) return;

                //

                _inverseMatrix$1.copy( matrixWorld ).invert();
                _ray$1.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$1 );

                const localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
                const localThresholdSq = localThreshold * localThreshold;

                const vStart = new Vector3();
                const vEnd = new Vector3();
                const interSegment = new Vector3();
                const interRay = new Vector3();
                const step = this.isLineSegments ? 2 : 1;

                if ( geometry.isBufferGeometry ) {

                        const index = geometry.index;
                        const attributes = geometry.attributes;
                        const positionAttribute = attributes.position;

                        if ( index !== null ) {

                                const indices = index.array;

                                for ( let i = 0, l = indices.length - 1; i < l; i += step ) {

                                        const a = indices[ i ];
                                        const b = indices[ i + 1 ];

                                        vStart.fromBufferAttribute( positionAttribute, a );
                                        vEnd.fromBufferAttribute( positionAttribute, b );

                                        const distSq = _ray$1.distanceSqToSegment( vStart, vEnd, interRay, interSegment );

                                        if ( distSq > localThresholdSq ) continue;

                                        interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation

                                        const distance = raycaster.ray.origin.distanceTo( interRay );

                                        if ( distance < raycaster.near || distance > raycaster.far ) continue;

                                        intersects.push( {

                                                distance: distance,
                                                // What do we want? intersection point on the ray or on the segment??
                                                // point: raycaster.ray.at( distance ),
                                                point: interSegment.clone().applyMatrix4( this.matrixWorld ),
                                                index: i,
                                                face: null,
                                                faceIndex: null,
                                                object: this

                                        } );

                                }

                        } else {

                                for ( let i = 0, l = positionAttribute.count - 1; i < l; i += step ) {

                                        vStart.fromBufferAttribute( positionAttribute, i );
                                        vEnd.fromBufferAttribute( positionAttribute, i + 1 );

                                        const distSq = _ray$1.distanceSqToSegment( vStart, vEnd, interRay, interSegment );

                                        if ( distSq > localThresholdSq ) continue;

                                        interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation

                                        const distance = raycaster.ray.origin.distanceTo( interRay );

                                        if ( distance < raycaster.near || distance > raycaster.far ) continue;

                                        intersects.push( {

                                                distance: distance,
                                                // What do we want? intersection point on the ray or on the segment??
                                                // point: raycaster.ray.at( distance ),
                                                point: interSegment.clone().applyMatrix4( this.matrixWorld ),
                                                index: i,
                                                face: null,
                                                faceIndex: null,
                                                object: this

                                        } );

                                }

                        }

                } else if ( geometry.isGeometry ) {

                        console.error( 'THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

                }

        },

        updateMorphTargets: function () {

                const geometry = this.geometry;

                if ( geometry.isBufferGeometry ) {

                        const morphAttributes = geometry.morphAttributes;
                        const keys = Object.keys( morphAttributes );

                        if ( keys.length > 0 ) {

                                const morphAttribute = morphAttributes[ keys[ 0 ] ];

                                if ( morphAttribute !== undefined ) {

                                        this.morphTargetInfluences = [];
                                        this.morphTargetDictionary = {};

                                        for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {

                                                const name = morphAttribute[ m ].name || String( m );

                                                this.morphTargetInfluences.push( 0 );
                                                this.morphTargetDictionary[ name ] = m;

                                        }

                                }

                        }

                } else {

                        const morphTargets = geometry.morphTargets;

                        if ( morphTargets !== undefined && morphTargets.length > 0 ) {

                                console.error( 'THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.' );

                        }

                }

        }

    } );

    const _start$1 = new Vector3();
    const _end$1 = new Vector3();

    function LineSegments( geometry, material ) {

        Line.call( this, geometry, material );

        this.type = 'LineSegments';

    }

    LineSegments.prototype = Object.assign( Object.create( Line.prototype ), {

        constructor: LineSegments,

        isLineSegments: true,

        computeLineDistances: function () {

                const geometry = this.geometry;

                if ( geometry.isBufferGeometry ) {

                        // we assume non-indexed geometry

                        if ( geometry.index === null ) {

                                const positionAttribute = geometry.attributes.position;
                                const lineDistances = [];

                                for ( let i = 0, l = positionAttribute.count; i < l; i += 2 ) {

                                        _start$1.fromBufferAttribute( positionAttribute, i );
                                        _end$1.fromBufferAttribute( positionAttribute, i + 1 );

                                        lineDistances[ i ] = ( i === 0 ) ? 0 : lineDistances[ i - 1 ];
                                        lineDistances[ i + 1 ] = lineDistances[ i ] + _start$1.distanceTo( _end$1 );

                                }

                                geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );

                        } else {

                                console.warn( 'THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );

                        }

                } else if ( geometry.isGeometry ) {

                        console.error( 'THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

                }

                return this;

        }

    } );

    function LineLoop( geometry, material ) {

        Line.call( this, geometry, material );

        this.type = 'LineLoop';

    }

    LineLoop.prototype = Object.assign( Object.create( Line.prototype ), {

        constructor: LineLoop,

        isLineLoop: true,

    } );

    /**
     * parameters = {
     *  color: <hex>,
     *  opacity: <float>,
     *  map: new THREE.Texture( <Image> ),
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  size: <float>,
     *  sizeAttenuation: <bool>
     *
     *  morphTargets: <bool>
     * }
     */

    function PointsMaterial( parameters ) {

        Material.call( this );

        this.type = 'PointsMaterial';

        this.color = new Color( 0xffffff );

        this.map = null;

        this.alphaMap = null;

        this.size = 1;
        this.sizeAttenuation = true;

        this.morphTargets = false;

        this.setValues( parameters );

    }

    PointsMaterial.prototype = Object.create( Material.prototype );
    PointsMaterial.prototype.constructor = PointsMaterial;

    PointsMaterial.prototype.isPointsMaterial = true;

    PointsMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        this.map = source.map;

        this.alphaMap = source.alphaMap;

        this.size = source.size;
        this.sizeAttenuation = source.sizeAttenuation;

        this.morphTargets = source.morphTargets;

        return this;

    };

    const _inverseMatrix$2 = new Matrix4();
    const _ray$2 = new Ray();
    const _sphere$3 = new Sphere();
    const _position$1 = new Vector3();

    function Points( geometry = new BufferGeometry(), material = new PointsMaterial() ) {

        Object3D.call( this );

        this.type = 'Points';

        this.geometry = geometry;
        this.material = material;

        this.updateMorphTargets();

    }

    Points.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Points,

        isPoints: true,

        copy: function ( source ) {

                Object3D.prototype.copy.call( this, source );

                this.material = source.material;
                this.geometry = source.geometry;

                return this;

        },

        raycast: function ( raycaster, intersects ) {

                const geometry = this.geometry;
                const matrixWorld = this.matrixWorld;
                const threshold = raycaster.params.Points.threshold;

                // Checking boundingSphere distance to ray

                if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();

                _sphere$3.copy( geometry.boundingSphere );
                _sphere$3.applyMatrix4( matrixWorld );
                _sphere$3.radius += threshold;

                if ( raycaster.ray.intersectsSphere( _sphere$3 ) === false ) return;

                //

                _inverseMatrix$2.copy( matrixWorld ).invert();
                _ray$2.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$2 );

                const localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
                const localThresholdSq = localThreshold * localThreshold;

                if ( geometry.isBufferGeometry ) {

                        const index = geometry.index;
                        const attributes = geometry.attributes;
                        const positionAttribute = attributes.position;

                        if ( index !== null ) {

                                const indices = index.array;

                                for ( let i = 0, il = indices.length; i < il; i ++ ) {

                                        const a = indices[ i ];

                                        _position$1.fromBufferAttribute( positionAttribute, a );

                                        testPoint( _position$1, a, localThresholdSq, matrixWorld, raycaster, intersects, this );

                                }

                        } else {

                                for ( let i = 0, l = positionAttribute.count; i < l; i ++ ) {

                                        _position$1.fromBufferAttribute( positionAttribute, i );

                                        testPoint( _position$1, i, localThresholdSq, matrixWorld, raycaster, intersects, this );

                                }

                        }

                } else {

                        console.error( 'THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );

                }

        },

        updateMorphTargets: function () {

                const geometry = this.geometry;

                if ( geometry.isBufferGeometry ) {

                        const morphAttributes = geometry.morphAttributes;
                        const keys = Object.keys( morphAttributes );

                        if ( keys.length > 0 ) {

                                const morphAttribute = morphAttributes[ keys[ 0 ] ];

                                if ( morphAttribute !== undefined ) {

                                        this.morphTargetInfluences = [];
                                        this.morphTargetDictionary = {};

                                        for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {

                                                const name = morphAttribute[ m ].name || String( m );

                                                this.morphTargetInfluences.push( 0 );
                                                this.morphTargetDictionary[ name ] = m;

                                        }

                                }

                        }

                } else {

                        const morphTargets = geometry.morphTargets;

                        if ( morphTargets !== undefined && morphTargets.length > 0 ) {

                                console.error( 'THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.' );

                        }

                }

        }

    } );

    function testPoint( point, index, localThresholdSq, matrixWorld, raycaster, intersects, object ) {

        const rayPointDistanceSq = _ray$2.distanceSqToPoint( point );

        if ( rayPointDistanceSq < localThresholdSq ) {

                const intersectPoint = new Vector3();

                _ray$2.closestPointToPoint( point, intersectPoint );
                intersectPoint.applyMatrix4( matrixWorld );

                const distance = raycaster.ray.origin.distanceTo( intersectPoint );

                if ( distance < raycaster.near || distance > raycaster.far ) return;

                intersects.push( {

                        distance: distance,
                        distanceToRay: Math.sqrt( rayPointDistanceSq ),
                        point: intersectPoint,
                        index: index,
                        face: null,
                        object: object

                } );

        }

    }

    function VideoTexture( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {

        Texture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );

        this.format = format !== undefined ? format : RGBFormat;

        this.minFilter = minFilter !== undefined ? minFilter : LinearFilter;
        this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;

        this.generateMipmaps = false;

        const scope = this;

        function updateVideo() {

                scope.needsUpdate = true;
                video.requestVideoFrameCallback( updateVideo );

        }

        if ( 'requestVideoFrameCallback' in video ) {

                video.requestVideoFrameCallback( updateVideo );

        }

    }

    VideoTexture.prototype = Object.assign( Object.create( Texture.prototype ), {

        constructor: VideoTexture,

        clone: function () {

                return new this.constructor( this.image ).copy( this );

        },

        isVideoTexture: true,

        update: function () {

                const video = this.image;
                const hasVideoFrameCallback = 'requestVideoFrameCallback' in video;

                if ( hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA ) {

                        this.needsUpdate = true;

                }

        }

    } );

    function CompressedTexture( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {

        Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );

        this.image = { width: width, height: height };
        this.mipmaps = mipmaps;

        // no flipping for cube textures
        // (also flipping doesn't work for compressed textures )

        this.flipY = false;

        // can't generate mipmaps for compressed textures
        // mips must be embedded in DDS files

        this.generateMipmaps = false;

    }

    CompressedTexture.prototype = Object.create( Texture.prototype );
    CompressedTexture.prototype.constructor = CompressedTexture;

    CompressedTexture.prototype.isCompressedTexture = true;

    function CanvasTexture( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {

        Texture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );

        this.needsUpdate = true;

    }

    CanvasTexture.prototype = Object.create( Texture.prototype );
    CanvasTexture.prototype.constructor = CanvasTexture;
    CanvasTexture.prototype.isCanvasTexture = true;

    function DepthTexture( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {

        format = format !== undefined ? format : DepthFormat;

        if ( format !== DepthFormat && format !== DepthStencilFormat ) {

                throw new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' );

        }

        if ( type === undefined && format === DepthFormat ) type = UnsignedShortType;
        if ( type === undefined && format === DepthStencilFormat ) type = UnsignedInt248Type;

        Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );

        this.image = { width: width, height: height };

        this.magFilter = magFilter !== undefined ? magFilter : NearestFilter;
        this.minFilter = minFilter !== undefined ? minFilter : NearestFilter;

        this.flipY = false;
        this.generateMipmaps = false;

    }

    DepthTexture.prototype = Object.create( Texture.prototype );
    DepthTexture.prototype.constructor = DepthTexture;
    DepthTexture.prototype.isDepthTexture = true;

    class CircleGeometry extends BufferGeometry {

        constructor( radius = 1, segments = 8, thetaStart = 0, thetaLength = Math.PI * 2 ) {

                super();

                this.type = 'CircleGeometry';

                this.parameters = {
                        radius: radius,
                        segments: segments,
                        thetaStart: thetaStart,
                        thetaLength: thetaLength
                };

                segments = Math.max( 3, segments );

                // buffers

                const indices = [];
                const vertices = [];
                const normals = [];
                const uvs = [];

                // helper variables

                const vertex = new Vector3();
                const uv = new Vector2();

                // center point

                vertices.push( 0, 0, 0 );
                normals.push( 0, 0, 1 );
                uvs.push( 0.5, 0.5 );

                for ( let s = 0, i = 3; s <= segments; s ++, i += 3 ) {

                        const segment = thetaStart + s / segments * thetaLength;

                        // vertex

                        vertex.x = radius * Math.cos( segment );
                        vertex.y = radius * Math.sin( segment );

                        vertices.push( vertex.x, vertex.y, vertex.z );

                        // normal

                        normals.push( 0, 0, 1 );

                        // uvs

                        uv.x = ( vertices[ i ] / radius + 1 ) / 2;
                        uv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;

                        uvs.push( uv.x, uv.y );

                }

                // indices

                for ( let i = 1; i <= segments; i ++ ) {

                        indices.push( i, i + 1, 0 );

                }

                // build geometry

                this.setIndex( indices );
                this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
                this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
                this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );

        }

    }

    new Vector3();
    new Vector3();
    new Vector3();
    new Triangle();

    /**
     * Port from https://github.com/mapbox/earcut (v2.2.2)
     */

    const Earcut = {

        triangulate: function ( data, holeIndices, dim ) {

                dim = dim || 2;

                const hasHoles = holeIndices && holeIndices.length;
                const outerLen = hasHoles ? holeIndices[ 0 ] * dim : data.length;
                let outerNode = linkedList$1( data, 0, outerLen, dim, true );
                const triangles = [];

                if ( ! outerNode || outerNode.next === outerNode.prev ) return triangles;

                let minX, minY, maxX, maxY, x, y, invSize;

                if ( hasHoles ) outerNode = eliminateHoles$1( data, holeIndices, outerNode, dim );

                // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
                if ( data.length > 80 * dim ) {

                        minX = maxX = data[ 0 ];
                        minY = maxY = data[ 1 ];

                        for ( let i = dim; i < outerLen; i += dim ) {

                                x = data[ i ];
                                y = data[ i + 1 ];
                                if ( x < minX ) minX = x;
                                if ( y < minY ) minY = y;
                                if ( x > maxX ) maxX = x;
                                if ( y > maxY ) maxY = y;

                        }

                        // minX, minY and invSize are later used to transform coords into integers for z-order calculation
                        invSize = Math.max( maxX - minX, maxY - minY );
                        invSize = invSize !== 0 ? 1 / invSize : 0;

                }

                earcutLinked$1( outerNode, triangles, dim, minX, minY, invSize );

                return triangles;

        }

    };

    // create a circular doubly linked list from polygon points in the specified winding order
    function linkedList$1( data, start, end, dim, clockwise ) {

        let i, last;

        if ( clockwise === ( signedArea$2( data, start, end, dim ) > 0 ) ) {

                for ( i = start; i < end; i += dim ) last = insertNode$2( i, data[ i ], data[ i + 1 ], last );

        } else {

                for ( i = end - dim; i >= start; i -= dim ) last = insertNode$2( i, data[ i ], data[ i + 1 ], last );

        }

        if ( last && equals$2( last, last.next ) ) {

                removeNode$2( last );
                last = last.next;

        }

        return last;

    }

    // eliminate colinear or duplicate points
    function filterPoints$1( start, end ) {

        if ( ! start ) return start;
        if ( ! end ) end = start;

        let p = start,
                again;
        do {

                again = false;

                if ( ! p.steiner && ( equals$2( p, p.next ) || area$1( p.prev, p, p.next ) === 0 ) ) {

                        removeNode$2( p );
                        p = end = p.prev;
                        if ( p === p.next ) break;
                        again = true;

                } else {

                        p = p.next;

                }

        } while ( again || p !== end );

        return end;

    }

    // main ear slicing loop which triangulates a polygon (given as a linked list)
    function earcutLinked$1( ear, triangles, dim, minX, minY, invSize, pass ) {

        if ( ! ear ) return;

        // interlink polygon nodes in z-order
        if ( ! pass && invSize ) indexCurve$1( ear, minX, minY, invSize );

        let stop = ear,
                prev, next;

        // iterate through ears, slicing them one by one
        while ( ear.prev !== ear.next ) {

                prev = ear.prev;
                next = ear.next;

                if ( invSize ? isEarHashed$1( ear, minX, minY, invSize ) : isEar$1( ear ) ) {

                        // cut off the triangle
                        triangles.push( prev.i / dim );
                        triangles.push( ear.i / dim );
                        triangles.push( next.i / dim );

                        removeNode$2( ear );

                        // skipping the next vertex leads to less sliver triangles
                        ear = next.next;
                        stop = next.next;

                        continue;

                }

                ear = next;

                // if we looped through the whole remaining polygon and can't find any more ears
                if ( ear === stop ) {

                        // try filtering points and slicing again
                        if ( ! pass ) {

                                earcutLinked$1( filterPoints$1( ear ), triangles, dim, minX, minY, invSize, 1 );

                                // if this didn't work, try curing all small self-intersections locally

                        } else if ( pass === 1 ) {

                                ear = cureLocalIntersections$1( filterPoints$1( ear ), triangles, dim );
                                earcutLinked$1( ear, triangles, dim, minX, minY, invSize, 2 );

                                // as a last resort, try splitting the remaining polygon into two

                        } else if ( pass === 2 ) {

                                splitEarcut$1( ear, triangles, dim, minX, minY, invSize );

                        }

                        break;

                }

        }

    }

    // check whether a polygon node forms a valid ear with adjacent nodes
    function isEar$1( ear ) {

        const a = ear.prev,
                b = ear,
                c = ear.next;

        if ( area$1( a, b, c ) >= 0 ) return false; // reflex, can't be an ear

        // now make sure we don't have other points inside the potential ear
        let p = ear.next.next;

        while ( p !== ear.prev ) {

                if ( pointInTriangle$1( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&
                        area$1( p.prev, p, p.next ) >= 0 ) return false;
                p = p.next;

        }

        return true;

    }

    function isEarHashed$1( ear, minX, minY, invSize ) {

        const a = ear.prev,
                b = ear,
                c = ear.next;

        if ( area$1( a, b, c ) >= 0 ) return false; // reflex, can't be an ear

        // triangle bbox; min & max are calculated like this for speed
        const minTX = a.x < b.x ? ( a.x < c.x ? a.x : c.x ) : ( b.x < c.x ? b.x : c.x ),
                minTY = a.y < b.y ? ( a.y < c.y ? a.y : c.y ) : ( b.y < c.y ? b.y : c.y ),
                maxTX = a.x > b.x ? ( a.x > c.x ? a.x : c.x ) : ( b.x > c.x ? b.x : c.x ),
                maxTY = a.y > b.y ? ( a.y > c.y ? a.y : c.y ) : ( b.y > c.y ? b.y : c.y );

        // z-order range for the current triangle bbox;
        const minZ = zOrder$1( minTX, minTY, minX, minY, invSize ),
                maxZ = zOrder$1( maxTX, maxTY, minX, minY, invSize );

        let p = ear.prevZ,
                n = ear.nextZ;

        // look for points inside the triangle in both directions
        while ( p && p.z >= minZ && n && n.z <= maxZ ) {

                if ( p !== ear.prev && p !== ear.next &&
                        pointInTriangle$1( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&
                        area$1( p.prev, p, p.next ) >= 0 ) return false;
                p = p.prevZ;

                if ( n !== ear.prev && n !== ear.next &&
                        pointInTriangle$1( a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y ) &&
                        area$1( n.prev, n, n.next ) >= 0 ) return false;
                n = n.nextZ;

        }

        // look for remaining points in decreasing z-order
        while ( p && p.z >= minZ ) {

                if ( p !== ear.prev && p !== ear.next &&
                        pointInTriangle$1( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&
                        area$1( p.prev, p, p.next ) >= 0 ) return false;
                p = p.prevZ;

        }

        // look for remaining points in increasing z-order
        while ( n && n.z <= maxZ ) {

                if ( n !== ear.prev && n !== ear.next &&
                        pointInTriangle$1( a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y ) &&
                        area$1( n.prev, n, n.next ) >= 0 ) return false;
                n = n.nextZ;

        }

        return true;

    }

    // go through all polygon nodes and cure small local self-intersections
    function cureLocalIntersections$1( start, triangles, dim ) {

        let p = start;
        do {

                const a = p.prev,
                        b = p.next.next;

                if ( ! equals$2( a, b ) && intersects$2( a, p, p.next, b ) && locallyInside$1( a, b ) && locallyInside$1( b, a ) ) {

                        triangles.push( a.i / dim );
                        triangles.push( p.i / dim );
                        triangles.push( b.i / dim );

                        // remove two nodes involved
                        removeNode$2( p );
                        removeNode$2( p.next );

                        p = start = b;

                }

                p = p.next;

        } while ( p !== start );

        return filterPoints$1( p );

    }

    // try splitting polygon into two and triangulate them independently
    function splitEarcut$1( start, triangles, dim, minX, minY, invSize ) {

        // look for a valid diagonal that divides the polygon into two
        let a = start;
        do {

                let b = a.next.next;
                while ( b !== a.prev ) {

                        if ( a.i !== b.i && isValidDiagonal$1( a, b ) ) {

                                // split the polygon in two by the diagonal
                                let c = splitPolygon$1( a, b );

                                // filter colinear points around the cuts
                                a = filterPoints$1( a, a.next );
                                c = filterPoints$1( c, c.next );

                                // run earcut on each half
                                earcutLinked$1( a, triangles, dim, minX, minY, invSize );
                                earcutLinked$1( c, triangles, dim, minX, minY, invSize );
                                return;

                        }

                        b = b.next;

                }

                a = a.next;

        } while ( a !== start );

    }

    // link every hole into the outer loop, producing a single-ring polygon without holes
    function eliminateHoles$1( data, holeIndices, outerNode, dim ) {

        const queue = [];
        let i, len, start, end, list;

        for ( i = 0, len = holeIndices.length; i < len; i ++ ) {

                start = holeIndices[ i ] * dim;
                end = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length;
                list = linkedList$1( data, start, end, dim, false );
                if ( list === list.next ) list.steiner = true;
                queue.push( getLeftmost$1( list ) );

        }

        queue.sort( compareX$1 );

        // process holes from left to right
        for ( i = 0; i < queue.length; i ++ ) {

                eliminateHole$1( queue[ i ], outerNode );
                outerNode = filterPoints$1( outerNode, outerNode.next );

        }

        return outerNode;

    }

    function compareX$1( a, b ) {

        return a.x - b.x;

    }

    // find a bridge between vertices that connects hole with an outer ring and and link it
    function eliminateHole$1( hole, outerNode ) {

        outerNode = findHoleBridge$1( hole, outerNode );
        if ( outerNode ) {

                const b = splitPolygon$1( outerNode, hole );

                // filter collinear points around the cuts
                filterPoints$1( outerNode, outerNode.next );
                filterPoints$1( b, b.next );

        }

    }

    // David Eberly's algorithm for finding a bridge between hole and outer polygon
    function findHoleBridge$1( hole, outerNode ) {

        let p = outerNode;
        const hx = hole.x;
        const hy = hole.y;
        let qx = - Infinity, m;

        // find a segment intersected by a ray from the hole's leftmost point to the left;
        // segment's endpoint with lesser x will be potential connection point
        do {

                if ( hy <= p.y && hy >= p.next.y && p.next.y !== p.y ) {

                        const x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y );
                        if ( x <= hx && x > qx ) {

                                qx = x;
                                if ( x === hx ) {

                                        if ( hy === p.y ) return p;
                                        if ( hy === p.next.y ) return p.next;

                                }

                                m = p.x < p.next.x ? p : p.next;

                        }

                }

                p = p.next;

        } while ( p !== outerNode );

        if ( ! m ) return null;

        if ( hx === qx ) return m; // hole touches outer segment; pick leftmost endpoint

        // look for points inside the triangle of hole point, segment intersection and endpoint;
        // if there are no points found, we have a valid connection;
        // otherwise choose the point of the minimum angle with the ray as connection point

        const stop = m,
                mx = m.x,
                my = m.y;
        let tanMin = Infinity, tan;

        p = m;

        do {

                if ( hx >= p.x && p.x >= mx && hx !== p.x &&
                                pointInTriangle$1( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {

                        tan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential

                        if ( locallyInside$1( p, hole ) && ( tan < tanMin || ( tan === tanMin && ( p.x > m.x || ( p.x === m.x && sectorContainsSector$1( m, p ) ) ) ) ) ) {

                                m = p;
                                tanMin = tan;

                        }

                }

                p = p.next;

        } while ( p !== stop );

        return m;

    }

    // whether sector in vertex m contains sector in vertex p in the same coordinates
    function sectorContainsSector$1( m, p ) {

        return area$1( m.prev, m, p.prev ) < 0 && area$1( p.next, m, m.next ) < 0;

    }

    // interlink polygon nodes in z-order
    function indexCurve$1( start, minX, minY, invSize ) {

        let p = start;
        do {

                if ( p.z === null ) p.z = zOrder$1( p.x, p.y, minX, minY, invSize );
                p.prevZ = p.prev;
                p.nextZ = p.next;
                p = p.next;

        } while ( p !== start );

        p.prevZ.nextZ = null;
        p.prevZ = null;

        sortLinked$1( p );

    }

    // Simon Tatham's linked list merge sort algorithm
    // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
    function sortLinked$1( list ) {

        let i, p, q, e, tail, numMerges, pSize, qSize,
                inSize = 1;

        do {

                p = list;
                list = null;
                tail = null;
                numMerges = 0;

                while ( p ) {

                        numMerges ++;
                        q = p;
                        pSize = 0;
                        for ( i = 0; i < inSize; i ++ ) {

                                pSize ++;
                                q = q.nextZ;
                                if ( ! q ) break;

                        }

                        qSize = inSize;

                        while ( pSize > 0 || ( qSize > 0 && q ) ) {

                                if ( pSize !== 0 && ( qSize === 0 || ! q || p.z <= q.z ) ) {

                                        e = p;
                                        p = p.nextZ;
                                        pSize --;

                                } else {

                                        e = q;
                                        q = q.nextZ;
                                        qSize --;

                                }

                                if ( tail ) tail.nextZ = e;
                                else list = e;

                                e.prevZ = tail;
                                tail = e;

                        }

                        p = q;

                }

                tail.nextZ = null;
                inSize *= 2;

        } while ( numMerges > 1 );

        return list;

    }

    // z-order of a point given coords and inverse of the longer side of data bbox
    function zOrder$1( x, y, minX, minY, invSize ) {

        // coords are transformed into non-negative 15-bit integer range
        x = 32767 * ( x - minX ) * invSize;
        y = 32767 * ( y - minY ) * invSize;

        x = ( x | ( x << 8 ) ) & 0x00FF00FF;
        x = ( x | ( x << 4 ) ) & 0x0F0F0F0F;
        x = ( x | ( x << 2 ) ) & 0x33333333;
        x = ( x | ( x << 1 ) ) & 0x55555555;

        y = ( y | ( y << 8 ) ) & 0x00FF00FF;
        y = ( y | ( y << 4 ) ) & 0x0F0F0F0F;
        y = ( y | ( y << 2 ) ) & 0x33333333;
        y = ( y | ( y << 1 ) ) & 0x55555555;

        return x | ( y << 1 );

    }

    // find the leftmost node of a polygon ring
    function getLeftmost$1( start ) {

        let p = start,
                leftmost = start;
        do {

                if ( p.x < leftmost.x || ( p.x === leftmost.x && p.y < leftmost.y ) ) leftmost = p;
                p = p.next;

        } while ( p !== start );

        return leftmost;

    }

    // check if a point lies within a convex triangle
    function pointInTriangle$1( ax, ay, bx, by, cx, cy, px, py ) {

        return ( cx - px ) * ( ay - py ) - ( ax - px ) * ( cy - py ) >= 0 &&
                        ( ax - px ) * ( by - py ) - ( bx - px ) * ( ay - py ) >= 0 &&
                        ( bx - px ) * ( cy - py ) - ( cx - px ) * ( by - py ) >= 0;

    }

    // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
    function isValidDiagonal$1( a, b ) {

        return a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon$1( a, b ) && // dones't intersect other edges
                ( locallyInside$1( a, b ) && locallyInside$1( b, a ) && middleInside$1( a, b ) && // locally visible
                ( area$1( a.prev, a, b.prev ) || area$1( a, b.prev, b ) ) || // does not create opposite-facing sectors
                equals$2( a, b ) && area$1( a.prev, a, a.next ) > 0 && area$1( b.prev, b, b.next ) > 0 ); // special zero-length case

    }

    // signed area of a triangle
    function area$1( p, q, r ) {

        return ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );

    }

    // check if two points are equal
    function equals$2( p1, p2 ) {

        return p1.x === p2.x && p1.y === p2.y;

    }

    // check if two segments intersect
    function intersects$2( p1, q1, p2, q2 ) {

        const o1 = sign$2( area$1( p1, q1, p2 ) );
        const o2 = sign$2( area$1( p1, q1, q2 ) );
        const o3 = sign$2( area$1( p2, q2, p1 ) );
        const o4 = sign$2( area$1( p2, q2, q1 ) );

        if ( o1 !== o2 && o3 !== o4 ) return true; // general case

        if ( o1 === 0 && onSegment$1( p1, p2, q1 ) ) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
        if ( o2 === 0 && onSegment$1( p1, q2, q1 ) ) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
        if ( o3 === 0 && onSegment$1( p2, p1, q2 ) ) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
        if ( o4 === 0 && onSegment$1( p2, q1, q2 ) ) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2

        return false;

    }

    // for collinear points p, q, r, check if point q lies on segment pr
    function onSegment$1( p, q, r ) {

        return q.x <= Math.max( p.x, r.x ) && q.x >= Math.min( p.x, r.x ) && q.y <= Math.max( p.y, r.y ) && q.y >= Math.min( p.y, r.y );

    }

    function sign$2( num ) {

        return num > 0 ? 1 : num < 0 ? - 1 : 0;

    }

    // check if a polygon diagonal intersects any polygon segments
    function intersectsPolygon$1( a, b ) {

        let p = a;
        do {

                if ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
                                intersects$2( p, p.next, a, b ) ) return true;
                p = p.next;

        } while ( p !== a );

        return false;

    }

    // check if a polygon diagonal is locally inside the polygon
    function locallyInside$1( a, b ) {

        return area$1( a.prev, a, a.next ) < 0 ?
                area$1( a, b, a.next ) >= 0 && area$1( a, a.prev, b ) >= 0 :
                area$1( a, b, a.prev ) < 0 || area$1( a, a.next, b ) < 0;

    }

    // check if the middle point of a polygon diagonal is inside the polygon
    function middleInside$1( a, b ) {

        let p = a,
                inside = false;
        const px = ( a.x + b.x ) / 2,
                py = ( a.y + b.y ) / 2;
        do {

                if ( ( ( p.y > py ) !== ( p.next.y > py ) ) && p.next.y !== p.y &&
                                ( px < ( p.next.x - p.x ) * ( py - p.y ) / ( p.next.y - p.y ) + p.x ) )
                        inside = ! inside;
                p = p.next;

        } while ( p !== a );

        return inside;

    }

    // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
    // if one belongs to the outer ring and another to a hole, it merges it into a single ring
    function splitPolygon$1( a, b ) {

        const a2 = new Node$1( a.i, a.x, a.y ),
                b2 = new Node$1( b.i, b.x, b.y ),
                an = a.next,
                bp = b.prev;

        a.next = b;
        b.prev = a;

        a2.next = an;
        an.prev = a2;

        b2.next = a2;
        a2.prev = b2;

        bp.next = b2;
        b2.prev = bp;

        return b2;

    }

    // create a node and optionally link it with previous one (in a circular doubly linked list)
    function insertNode$2( i, x, y, last ) {

        const p = new Node$1( i, x, y );

        if ( ! last ) {

                p.prev = p;
                p.next = p;

        } else {

                p.next = last.next;
                p.prev = last;
                last.next.prev = p;
                last.next = p;

        }

        return p;

    }

    function removeNode$2( p ) {

        p.next.prev = p.prev;
        p.prev.next = p.next;

        if ( p.prevZ ) p.prevZ.nextZ = p.nextZ;
        if ( p.nextZ ) p.nextZ.prevZ = p.prevZ;

    }

    function Node$1( i, x, y ) {

        // vertex index in coordinates array
        this.i = i;

        // vertex coordinates
        this.x = x;
        this.y = y;

        // previous and next vertex nodes in a polygon ring
        this.prev = null;
        this.next = null;

        // z-order curve value
        this.z = null;

        // previous and next nodes in z-order
        this.prevZ = null;
        this.nextZ = null;

        // indicates whether this is a steiner point
        this.steiner = false;

    }

    function signedArea$2( data, start, end, dim ) {

        let sum = 0;
        for ( let i = start, j = end - dim; i < end; i += dim ) {

                sum += ( data[ j ] - data[ i ] ) * ( data[ i + 1 ] + data[ j + 1 ] );
                j = i;

        }

        return sum;

    }

    const ShapeUtils = {

        // calculate area of the contour polygon

        area: function ( contour ) {

                const n = contour.length;
                let a = 0.0;

                for ( let p = n - 1, q = 0; q < n; p = q ++ ) {

                        a += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;

                }

                return a * 0.5;

        },

        isClockWise: function ( pts ) {

                return ShapeUtils.area( pts ) < 0;

        },

        triangulateShape: function ( contour, holes ) {

                const vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]
                const holeIndices = []; // array of hole indices
                const faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]

                removeDupEndPts( contour );
                addContour( vertices, contour );

                //

                let holeIndex = contour.length;

                holes.forEach( removeDupEndPts );

                for ( let i = 0; i < holes.length; i ++ ) {

                        holeIndices.push( holeIndex );
                        holeIndex += holes[ i ].length;
                        addContour( vertices, holes[ i ] );

                }

                //

                const triangles = Earcut.triangulate( vertices, holeIndices );

                //

                for ( let i = 0; i < triangles.length; i += 3 ) {

                        faces.push( triangles.slice( i, i + 3 ) );

                }

                return faces;

        }

    };

    function removeDupEndPts( points ) {

        const l = points.length;

        if ( l > 2 && points[ l - 1 ].equals( points[ 0 ] ) ) {

                points.pop();

        }

    }

    function addContour( vertices, contour ) {

        for ( let i = 0; i < contour.length; i ++ ) {

                vertices.push( contour[ i ].x );
                vertices.push( contour[ i ].y );

        }

    }

    /**
     * Creates extruded geometry from a path shape.
     *
     * parameters = {
     *
     *  curveSegments: <int>, // number of points on the curves
     *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too
     *  depth: <float>, // Depth to extrude the shape
     *
     *  bevelEnabled: <bool>, // turn on bevel
     *  bevelThickness: <float>, // how deep into the original shape bevel goes
     *  bevelSize: <float>, // how far from shape outline (including bevelOffset) is bevel
     *  bevelOffset: <float>, // how far from shape outline does bevel start
     *  bevelSegments: <int>, // number of bevel layers
     *
     *  extrudePath: <THREE.Curve> // curve to extrude shape along
     *
     *  UVGenerator: <Object> // object that provides UV generator functions
     *
     * }
     */

    class ExtrudeGeometry extends BufferGeometry {

        constructor( shapes, options ) {

                super();

                this.type = 'ExtrudeGeometry';

                this.parameters = {
                        shapes: shapes,
                        options: options
                };

                shapes = Array.isArray( shapes ) ? shapes : [ shapes ];

                const scope = this;

                const verticesArray = [];
                const uvArray = [];

                for ( let i = 0, l = shapes.length; i < l; i ++ ) {

                        const shape = shapes[ i ];
                        addShape( shape );

                }

                // build geometry

                this.setAttribute( 'position', new Float32BufferAttribute( verticesArray, 3 ) );
                this.setAttribute( 'uv', new Float32BufferAttribute( uvArray, 2 ) );

                this.computeVertexNormals();

                // functions

                function addShape( shape ) {

                        const placeholder = [];

                        // options

                        const curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
                        const steps = options.steps !== undefined ? options.steps : 1;
                        let depth = options.depth !== undefined ? options.depth : 100;

                        let bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true;
                        let bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6;
                        let bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2;
                        let bevelOffset = options.bevelOffset !== undefined ? options.bevelOffset : 0;
                        let bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;

                        const extrudePath = options.extrudePath;

                        const uvgen = options.UVGenerator !== undefined ? options.UVGenerator : WorldUVGenerator;

                        // deprecated options

                        if ( options.amount !== undefined ) {

                                console.warn( 'THREE.ExtrudeBufferGeometry: amount has been renamed to depth.' );
                                depth = options.amount;

                        }

                        //

                        let extrudePts, extrudeByPath = false;
                        let splineTube, binormal, normal, position2;

                        if ( extrudePath ) {

                                extrudePts = extrudePath.getSpacedPoints( steps );

                                extrudeByPath = true;
                                bevelEnabled = false; // bevels not supported for path extrusion

                                // SETUP TNB variables

                                // TODO1 - have a .isClosed in spline?

                                splineTube = extrudePath.computeFrenetFrames( steps, false );

                                // console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);

                                binormal = new Vector3();
                                normal = new Vector3();
                                position2 = new Vector3();

                        }

                        // Safeguards if bevels are not enabled

                        if ( ! bevelEnabled ) {

                                bevelSegments = 0;
                                bevelThickness = 0;
                                bevelSize = 0;
                                bevelOffset = 0;

                        }

                        // Variables initialization

                        const shapePoints = shape.extractPoints( curveSegments );

                        let vertices = shapePoints.shape;
                        const holes = shapePoints.holes;

                        const reverse = ! ShapeUtils.isClockWise( vertices );

                        if ( reverse ) {

                                vertices = vertices.reverse();

                                // Maybe we should also check if holes are in the opposite direction, just to be safe ...

                                for ( let h = 0, hl = holes.length; h < hl; h ++ ) {

                                        const ahole = holes[ h ];

                                        if ( ShapeUtils.isClockWise( ahole ) ) {

                                                holes[ h ] = ahole.reverse();

                                        }

                                }

                        }


                        const faces = ShapeUtils.triangulateShape( vertices, holes );

                        /* Vertices */

                        const contour = vertices; // vertices has all points but contour has only points of circumference

                        for ( let h = 0, hl = holes.length; h < hl; h ++ ) {

                                const ahole = holes[ h ];

                                vertices = vertices.concat( ahole );

                        }


                        function scalePt2( pt, vec, size ) {

                                if ( ! vec ) console.error( 'THREE.ExtrudeGeometry: vec does not exist' );

                                return vec.clone().multiplyScalar( size ).add( pt );

                        }

                        const vlen = vertices.length, flen = faces.length;


                        // Find directions for point movement


                        function getBevelVec( inPt, inPrev, inNext ) {

                                // computes for inPt the corresponding point inPt' on a new contour
                                //   shifted by 1 unit (length of normalized vector) to the left
                                // if we walk along contour clockwise, this new contour is outside the old one
                                //
                                // inPt' is the intersection of the two lines parallel to the two
                                //  adjacent edges of inPt at a distance of 1 unit on the left side.

                                let v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt

                                // good reading for geometry algorithms (here: line-line intersection)
                                // http://geomalgorithms.com/a05-_intersect-1.html

                                const v_prev_x = inPt.x - inPrev.x,
                                        v_prev_y = inPt.y - inPrev.y;
                                const v_next_x = inNext.x - inPt.x,
                                        v_next_y = inNext.y - inPt.y;

                                const v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );

                                // check for collinear edges
                                const collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );

                                if ( Math.abs( collinear0 ) > Number.EPSILON ) {

                                        // not collinear

                                        // length of vectors for normalizing

                                        const v_prev_len = Math.sqrt( v_prev_lensq );
                                        const v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y );

                                        // shift adjacent points by unit vectors to the left

                                        const ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len );
                                        const ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len );

                                        const ptNextShift_x = ( inNext.x - v_next_y / v_next_len );
                                        const ptNextShift_y = ( inNext.y + v_next_x / v_next_len );

                                        // scaling factor for v_prev to intersection point

                                        const sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y -
                                                        ( ptNextShift_y - ptPrevShift_y ) * v_next_x ) /
                                                ( v_prev_x * v_next_y - v_prev_y * v_next_x );

                                        // vector from inPt to intersection point

                                        v_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x );
                                        v_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y );

                                        // Don't normalize!, otherwise sharp corners become ugly
                                        //  but prevent crazy spikes
                                        const v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y );
                                        if ( v_trans_lensq <= 2 ) {

                                                return new Vector2( v_trans_x, v_trans_y );

                                        } else {

                                                shrink_by = Math.sqrt( v_trans_lensq / 2 );

                                        }

                                } else {

                                        // handle special case of collinear edges

                                        let direction_eq = false; // assumes: opposite

                                        if ( v_prev_x > Number.EPSILON ) {

                                                if ( v_next_x > Number.EPSILON ) {

                                                        direction_eq = true;

                                                }

                                        } else {

                                                if ( v_prev_x < - Number.EPSILON ) {

                                                        if ( v_next_x < - Number.EPSILON ) {

                                                                direction_eq = true;

                                                        }

                                                } else {

                                                        if ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {

                                                                direction_eq = true;

                                                        }

                                                }

                                        }

                                        if ( direction_eq ) {

                                                // console.log("Warning: lines are a straight sequence");
                                                v_trans_x = - v_prev_y;
                                                v_trans_y = v_prev_x;
                                                shrink_by = Math.sqrt( v_prev_lensq );

                                        } else {

                                                // console.log("Warning: lines are a straight spike");
                                                v_trans_x = v_prev_x;
                                                v_trans_y = v_prev_y;
                                                shrink_by = Math.sqrt( v_prev_lensq / 2 );

                                        }

                                }

                                return new Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );

                        }


                        const contourMovements = [];

                        for ( let i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {

                                if ( j === il ) j = 0;
                                if ( k === il ) k = 0;

                                //  (j)---(i)---(k)
                                // console.log('i,j,k', i, j , k)

                                contourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );

                        }

                        const holesMovements = [];
                        let oneHoleMovements, verticesMovements = contourMovements.concat();

                        for ( let h = 0, hl = holes.length; h < hl; h ++ ) {

                                const ahole = holes[ h ];

                                oneHoleMovements = [];

                                for ( let i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {

                                        if ( j === il ) j = 0;
                                        if ( k === il ) k = 0;

                                        //  (j)---(i)---(k)
                                        oneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );

                                }

                                holesMovements.push( oneHoleMovements );
                                verticesMovements = verticesMovements.concat( oneHoleMovements );

                        }


                        // Loop bevelSegments, 1 for the front, 1 for the back

                        for ( let b = 0; b < bevelSegments; b ++ ) {

                                //for ( b = bevelSegments; b > 0; b -- ) {

                                const t = b / bevelSegments;
                                const z = bevelThickness * Math.cos( t * Math.PI / 2 );
                                const bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;

                                // contract shape

                                for ( let i = 0, il = contour.length; i < il; i ++ ) {

                                        const vert = scalePt2( contour[ i ], contourMovements[ i ], bs );

                                        v( vert.x, vert.y, - z );

                                }

                                // expand holes

                                for ( let h = 0, hl = holes.length; h < hl; h ++ ) {

                                        const ahole = holes[ h ];
                                        oneHoleMovements = holesMovements[ h ];

                                        for ( let i = 0, il = ahole.length; i < il; i ++ ) {

                                                const vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );

                                                v( vert.x, vert.y, - z );

                                        }

                                }

                        }

                        const bs = bevelSize + bevelOffset;

                        // Back facing vertices

                        for ( let i = 0; i < vlen; i ++ ) {

                                const vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];

                                if ( ! extrudeByPath ) {

                                        v( vert.x, vert.y, 0 );

                                } else {

                                        // v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );

                                        normal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );
                                        binormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );

                                        position2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );

                                        v( position2.x, position2.y, position2.z );

                                }

                        }

                        // Add stepped vertices...
                        // Including front facing vertices

                        for ( let s = 1; s <= steps; s ++ ) {

                                for ( let i = 0; i < vlen; i ++ ) {

                                        const vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];

                                        if ( ! extrudeByPath ) {

                                                v( vert.x, vert.y, depth / steps * s );

                                        } else {

                                                // v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );

                                                normal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );
                                                binormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );

                                                position2.copy( extrudePts[ s ] ).add( normal ).add( binormal );

                                                v( position2.x, position2.y, position2.z );

                                        }

                                }

                        }


                        // Add bevel segments planes

                        //for ( b = 1; b <= bevelSegments; b ++ ) {
                        for ( let b = bevelSegments - 1; b >= 0; b -- ) {

                                const t = b / bevelSegments;
                                const z = bevelThickness * Math.cos( t * Math.PI / 2 );
                                const bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;

                                // contract shape

                                for ( let i = 0, il = contour.length; i < il; i ++ ) {

                                        const vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
                                        v( vert.x, vert.y, depth + z );

                                }

                                // expand holes

                                for ( let h = 0, hl = holes.length; h < hl; h ++ ) {

                                        const ahole = holes[ h ];
                                        oneHoleMovements = holesMovements[ h ];

                                        for ( let i = 0, il = ahole.length; i < il; i ++ ) {

                                                const vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );

                                                if ( ! extrudeByPath ) {

                                                        v( vert.x, vert.y, depth + z );

                                                } else {

                                                        v( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );

                                                }

                                        }

                                }

                        }

                        /* Faces */

                        // Top and bottom faces

                        buildLidFaces();

                        // Sides faces

                        buildSideFaces();


                        /////  Internal functions

                        function buildLidFaces() {

                                const start = verticesArray.length / 3;

                                if ( bevelEnabled ) {

                                        let layer = 0; // steps + 1
                                        let offset = vlen * layer;

                                        // Bottom faces

                                        for ( let i = 0; i < flen; i ++ ) {

                                                const face = faces[ i ];
                                                f3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );

                                        }

                                        layer = steps + bevelSegments * 2;
                                        offset = vlen * layer;

                                        // Top faces

                                        for ( let i = 0; i < flen; i ++ ) {

                                                const face = faces[ i ];
                                                f3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );

                                        }

                                } else {

                                        // Bottom faces

                                        for ( let i = 0; i < flen; i ++ ) {

                                                const face = faces[ i ];
                                                f3( face[ 2 ], face[ 1 ], face[ 0 ] );

                                        }

                                        // Top faces

                                        for ( let i = 0; i < flen; i ++ ) {

                                                const face = faces[ i ];
                                                f3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );

                                        }

                                }

                                scope.addGroup( start, verticesArray.length / 3 - start, 0 );

                        }

                        // Create faces for the z-sides of the shape

                        function buildSideFaces() {

                                const start = verticesArray.length / 3;
                                let layeroffset = 0;
                                sidewalls( contour, layeroffset );
                                layeroffset += contour.length;

                                for ( let h = 0, hl = holes.length; h < hl; h ++ ) {

                                        const ahole = holes[ h ];
                                        sidewalls( ahole, layeroffset );

                                        //, true
                                        layeroffset += ahole.length;

                                }


                                scope.addGroup( start, verticesArray.length / 3 - start, 1 );


                        }

                        function sidewalls( contour, layeroffset ) {

                                let i = contour.length;

                                while ( -- i >= 0 ) {

                                        const j = i;
                                        let k = i - 1;
                                        if ( k < 0 ) k = contour.length - 1;

                                        //console.log('b', i,j, i-1, k,vertices.length);

                                        for ( let s = 0, sl = ( steps + bevelSegments * 2 ); s < sl; s ++ ) {

                                                const slen1 = vlen * s;
                                                const slen2 = vlen * ( s + 1 );

                                                const a = layeroffset + j + slen1,
                                                        b = layeroffset + k + slen1,
                                                        c = layeroffset + k + slen2,
                                                        d = layeroffset + j + slen2;

                                                f4( a, b, c, d );

                                        }

                                }

                        }

                        function v( x, y, z ) {

                                placeholder.push( x );
                                placeholder.push( y );
                                placeholder.push( z );

                        }


                        function f3( a, b, c ) {

                                addVertex( a );
                                addVertex( b );
                                addVertex( c );

                                const nextIndex = verticesArray.length / 3;
                                const uvs = uvgen.generateTopUV( scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1 );

                                addUV( uvs[ 0 ] );
                                addUV( uvs[ 1 ] );
                                addUV( uvs[ 2 ] );

                        }

                        function f4( a, b, c, d ) {

                                addVertex( a );
                                addVertex( b );
                                addVertex( d );

                                addVertex( b );
                                addVertex( c );
                                addVertex( d );


                                const nextIndex = verticesArray.length / 3;
                                const uvs = uvgen.generateSideWallUV( scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1 );

                                addUV( uvs[ 0 ] );
                                addUV( uvs[ 1 ] );
                                addUV( uvs[ 3 ] );

                                addUV( uvs[ 1 ] );
                                addUV( uvs[ 2 ] );
                                addUV( uvs[ 3 ] );

                        }

                        function addVertex( index ) {

                                verticesArray.push( placeholder[ index * 3 + 0 ] );
                                verticesArray.push( placeholder[ index * 3 + 1 ] );
                                verticesArray.push( placeholder[ index * 3 + 2 ] );

                        }


                        function addUV( vector2 ) {

                                uvArray.push( vector2.x );
                                uvArray.push( vector2.y );

                        }

                }

        }

        toJSON() {

                const data = BufferGeometry.prototype.toJSON.call( this );

                const shapes = this.parameters.shapes;
                const options = this.parameters.options;

                return toJSON( shapes, options, data );

        }

    }

    const WorldUVGenerator = {

        generateTopUV: function ( geometry, vertices, indexA, indexB, indexC ) {

                const a_x = vertices[ indexA * 3 ];
                const a_y = vertices[ indexA * 3 + 1 ];
                const b_x = vertices[ indexB * 3 ];
                const b_y = vertices[ indexB * 3 + 1 ];
                const c_x = vertices[ indexC * 3 ];
                const c_y = vertices[ indexC * 3 + 1 ];

                return [
                        new Vector2( a_x, a_y ),
                        new Vector2( b_x, b_y ),
                        new Vector2( c_x, c_y )
                ];

        },

        generateSideWallUV: function ( geometry, vertices, indexA, indexB, indexC, indexD ) {

                const a_x = vertices[ indexA * 3 ];
                const a_y = vertices[ indexA * 3 + 1 ];
                const a_z = vertices[ indexA * 3 + 2 ];
                const b_x = vertices[ indexB * 3 ];
                const b_y = vertices[ indexB * 3 + 1 ];
                const b_z = vertices[ indexB * 3 + 2 ];
                const c_x = vertices[ indexC * 3 ];
                const c_y = vertices[ indexC * 3 + 1 ];
                const c_z = vertices[ indexC * 3 + 2 ];
                const d_x = vertices[ indexD * 3 ];
                const d_y = vertices[ indexD * 3 + 1 ];
                const d_z = vertices[ indexD * 3 + 2 ];

                if ( Math.abs( a_y - b_y ) < 0.01 ) {

                        return [
                                new Vector2( a_x, 1 - a_z ),
                                new Vector2( b_x, 1 - b_z ),
                                new Vector2( c_x, 1 - c_z ),
                                new Vector2( d_x, 1 - d_z )
                        ];

                } else {

                        return [
                                new Vector2( a_y, 1 - a_z ),
                                new Vector2( b_y, 1 - b_z ),
                                new Vector2( c_y, 1 - c_z ),
                                new Vector2( d_y, 1 - d_z )
                        ];

                }

        }

    };

    function toJSON( shapes, options, data ) {

        data.shapes = [];

        if ( Array.isArray( shapes ) ) {

                for ( let i = 0, l = shapes.length; i < l; i ++ ) {

                        const shape = shapes[ i ];

                        data.shapes.push( shape.uuid );

                }

        } else {

                data.shapes.push( shapes.uuid );

        }

        if ( options.extrudePath !== undefined ) data.options.extrudePath = options.extrudePath.toJSON();

        return data;

    }

    /**
     * Parametric Surfaces Geometry
     * based on the brilliant article by @prideout https://prideout.net/blog/old/blog/index.html@p=44.html
     */

    function ParametricGeometry( func, slices, stacks ) {

        BufferGeometry.call( this );

        this.type = 'ParametricGeometry';

        this.parameters = {
                func: func,
                slices: slices,
                stacks: stacks
        };

        // buffers

        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];

        const EPS = 0.00001;

        const normal = new Vector3();

        const p0 = new Vector3(), p1 = new Vector3();
        const pu = new Vector3(), pv = new Vector3();

        if ( func.length < 3 ) {

                console.error( 'THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.' );

        }

        // generate vertices, normals and uvs

        const sliceCount = slices + 1;

        for ( let i = 0; i <= stacks; i ++ ) {

                const v = i / stacks;

                for ( let j = 0; j <= slices; j ++ ) {

                        const u = j / slices;

                        // vertex

                        func( u, v, p0 );
                        vertices.push( p0.x, p0.y, p0.z );

                        // normal

                        // approximate tangent vectors via finite differences

                        if ( u - EPS >= 0 ) {

                                func( u - EPS, v, p1 );
                                pu.subVectors( p0, p1 );

                        } else {

                                func( u + EPS, v, p1 );
                                pu.subVectors( p1, p0 );

                        }

                        if ( v - EPS >= 0 ) {

                                func( u, v - EPS, p1 );
                                pv.subVectors( p0, p1 );

                        } else {

                                func( u, v + EPS, p1 );
                                pv.subVectors( p1, p0 );

                        }

                        // cross product of tangent vectors returns surface normal

                        normal.crossVectors( pu, pv ).normalize();
                        normals.push( normal.x, normal.y, normal.z );

                        // uv

                        uvs.push( u, v );

                }

        }

        // generate indices

        for ( let i = 0; i < stacks; i ++ ) {

                for ( let j = 0; j < slices; j ++ ) {

                        const a = i * sliceCount + j;
                        const b = i * sliceCount + j + 1;
                        const c = ( i + 1 ) * sliceCount + j + 1;
                        const d = ( i + 1 ) * sliceCount + j;

                        // faces one and two

                        indices.push( a, b, d );
                        indices.push( b, c, d );

                }

        }

        // build geometry

        this.setIndex( indices );
        this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
        this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
        this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );

    }

    ParametricGeometry.prototype = Object.create( BufferGeometry.prototype );
    ParametricGeometry.prototype.constructor = ParametricGeometry;

    class ShapeGeometry extends BufferGeometry {

        constructor( shapes, curveSegments = 12 ) {

                super();
                this.type = 'ShapeGeometry';

                this.parameters = {
                        shapes: shapes,
                        curveSegments: curveSegments
                };

                // buffers

                const indices = [];
                const vertices = [];
                const normals = [];
                const uvs = [];

                // helper variables

                let groupStart = 0;
                let groupCount = 0;

                // allow single and array values for "shapes" parameter

                if ( Array.isArray( shapes ) === false ) {

                        addShape( shapes );

                } else {

                        for ( let i = 0; i < shapes.length; i ++ ) {

                                addShape( shapes[ i ] );

                                this.addGroup( groupStart, groupCount, i ); // enables MultiMaterial support

                                groupStart += groupCount;
                                groupCount = 0;

                        }

                }

                // build geometry

                this.setIndex( indices );
                this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
                this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
                this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );


                // helper functions

                function addShape( shape ) {

                        const indexOffset = vertices.length / 3;
                        const points = shape.extractPoints( curveSegments );

                        let shapeVertices = points.shape;
                        const shapeHoles = points.holes;

                        // check direction of vertices

                        if ( ShapeUtils.isClockWise( shapeVertices ) === false ) {

                                shapeVertices = shapeVertices.reverse();

                        }

                        for ( let i = 0, l = shapeHoles.length; i < l; i ++ ) {

                                const shapeHole = shapeHoles[ i ];

                                if ( ShapeUtils.isClockWise( shapeHole ) === true ) {

                                        shapeHoles[ i ] = shapeHole.reverse();

                                }

                        }

                        const faces = ShapeUtils.triangulateShape( shapeVertices, shapeHoles );

                        // join vertices of inner and outer paths to a single array

                        for ( let i = 0, l = shapeHoles.length; i < l; i ++ ) {

                                const shapeHole = shapeHoles[ i ];
                                shapeVertices = shapeVertices.concat( shapeHole );

                        }

                        // vertices, normals, uvs

                        for ( let i = 0, l = shapeVertices.length; i < l; i ++ ) {

                                const vertex = shapeVertices[ i ];

                                vertices.push( vertex.x, vertex.y, 0 );
                                normals.push( 0, 0, 1 );
                                uvs.push( vertex.x, vertex.y ); // world uvs

                        }

                        // incides

                        for ( let i = 0, l = faces.length; i < l; i ++ ) {

                                const face = faces[ i ];

                                const a = face[ 0 ] + indexOffset;
                                const b = face[ 1 ] + indexOffset;
                                const c = face[ 2 ] + indexOffset;

                                indices.push( a, b, c );
                                groupCount += 3;

                        }

                }

        }

        toJSON() {

                const data = BufferGeometry.prototype.toJSON.call( this );

                const shapes = this.parameters.shapes;

                return toJSON$1( shapes, data );

        }

    }

    function toJSON$1( shapes, data ) {

        data.shapes = [];

        if ( Array.isArray( shapes ) ) {

                for ( let i = 0, l = shapes.length; i < l; i ++ ) {

                        const shape = shapes[ i ];

                        data.shapes.push( shape.uuid );

                }

        } else {

                data.shapes.push( shapes.uuid );

        }

        return data;

    }

    class SphereGeometry extends BufferGeometry {

        constructor( radius = 1, widthSegments = 8, heightSegments = 6, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI ) {

                super();
                this.type = 'SphereGeometry';

                this.parameters = {
                        radius: radius,
                        widthSegments: widthSegments,
                        heightSegments: heightSegments,
                        phiStart: phiStart,
                        phiLength: phiLength,
                        thetaStart: thetaStart,
                        thetaLength: thetaLength
                };

                widthSegments = Math.max( 3, Math.floor( widthSegments ) );
                heightSegments = Math.max( 2, Math.floor( heightSegments ) );

                const thetaEnd = Math.min( thetaStart + thetaLength, Math.PI );

                let index = 0;
                const grid = [];

                const vertex = new Vector3();
                const normal = new Vector3();

                // buffers

                const indices = [];
                const vertices = [];
                const normals = [];
                const uvs = [];

                // generate vertices, normals and uvs

                for ( let iy = 0; iy <= heightSegments; iy ++ ) {

                        const verticesRow = [];

                        const v = iy / heightSegments;

                        // special case for the poles

                        let uOffset = 0;

                        if ( iy == 0 && thetaStart == 0 ) {

                                uOffset = 0.5 / widthSegments;

                        } else if ( iy == heightSegments && thetaEnd == Math.PI ) {

                                uOffset = - 0.5 / widthSegments;

                        }

                        for ( let ix = 0; ix <= widthSegments; ix ++ ) {

                                const u = ix / widthSegments;

                                // vertex

                                vertex.x = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
                                vertex.y = radius * Math.cos( thetaStart + v * thetaLength );
                                vertex.z = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );

                                vertices.push( vertex.x, vertex.y, vertex.z );

                                // normal

                                normal.copy( vertex ).normalize();
                                normals.push( normal.x, normal.y, normal.z );

                                // uv

                                uvs.push( u + uOffset, 1 - v );

                                verticesRow.push( index ++ );

                        }

                        grid.push( verticesRow );

                }

                // indices

                for ( let iy = 0; iy < heightSegments; iy ++ ) {

                        for ( let ix = 0; ix < widthSegments; ix ++ ) {

                                const a = grid[ iy ][ ix + 1 ];
                                const b = grid[ iy ][ ix ];
                                const c = grid[ iy + 1 ][ ix ];
                                const d = grid[ iy + 1 ][ ix + 1 ];

                                if ( iy !== 0 || thetaStart > 0 ) indices.push( a, b, d );
                                if ( iy !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( b, c, d );

                        }

                }

                // build geometry

                this.setIndex( indices );
                this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
                this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
                this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );

        }

    }

    /**
     * parameters = {
     *  color: <THREE.Color>
     * }
     */

    function ShadowMaterial( parameters ) {

        Material.call( this );

        this.type = 'ShadowMaterial';

        this.color = new Color( 0x000000 );
        this.transparent = true;

        this.setValues( parameters );

    }

    ShadowMaterial.prototype = Object.create( Material.prototype );
    ShadowMaterial.prototype.constructor = ShadowMaterial;

    ShadowMaterial.prototype.isShadowMaterial = true;

    ShadowMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        return this;

    };

    function RawShaderMaterial( parameters ) {

        ShaderMaterial.call( this, parameters );

        this.type = 'RawShaderMaterial';

    }

    RawShaderMaterial.prototype = Object.create( ShaderMaterial.prototype );
    RawShaderMaterial.prototype.constructor = RawShaderMaterial;

    RawShaderMaterial.prototype.isRawShaderMaterial = true;

    /**
     * parameters = {
     *  color: <hex>,
     *  roughness: <float>,
     *  metalness: <float>,
     *  opacity: <float>,
     *
     *  map: new THREE.Texture( <Image> ),
     *
     *  lightMap: new THREE.Texture( <Image> ),
     *  lightMapIntensity: <float>
     *
     *  aoMap: new THREE.Texture( <Image> ),
     *  aoMapIntensity: <float>
     *
     *  emissive: <hex>,
     *  emissiveIntensity: <float>
     *  emissiveMap: new THREE.Texture( <Image> ),
     *
     *  bumpMap: new THREE.Texture( <Image> ),
     *  bumpScale: <float>,
     *
     *  normalMap: new THREE.Texture( <Image> ),
     *  normalMapType: THREE.TangentSpaceNormalMap,
     *  normalScale: <Vector2>,
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>,
     *
     *  roughnessMap: new THREE.Texture( <Image> ),
     *
     *  metalnessMap: new THREE.Texture( <Image> ),
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
     *  envMapIntensity: <float>
     *
     *  refractionRatio: <float>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function MeshStandardMaterial( parameters ) {

        Material.call( this );

        this.defines = { 'STANDARD': '' };

        this.type = 'MeshStandardMaterial';

        this.color = new Color( 0xffffff ); // diffuse
        this.roughness = 1.0;
        this.metalness = 0.0;

        this.map = null;

        this.lightMap = null;
        this.lightMapIntensity = 1.0;

        this.aoMap = null;
        this.aoMapIntensity = 1.0;

        this.emissive = new Color( 0x000000 );
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;

        this.bumpMap = null;
        this.bumpScale = 1;

        this.normalMap = null;
        this.normalMapType = TangentSpaceNormalMap;
        this.normalScale = new Vector2( 1, 1 );

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.roughnessMap = null;

        this.metalnessMap = null;

        this.alphaMap = null;

        this.envMap = null;
        this.envMapIntensity = 1.0;

        this.refractionRatio = 0.98;

        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';

        this.skinning = false;
        this.morphTargets = false;
        this.morphNormals = false;

        this.vertexTangents = false;

        this.setValues( parameters );

    }

    MeshStandardMaterial.prototype = Object.create( Material.prototype );
    MeshStandardMaterial.prototype.constructor = MeshStandardMaterial;

    MeshStandardMaterial.prototype.isMeshStandardMaterial = true;

    MeshStandardMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.defines = { 'STANDARD': '' };

        this.color.copy( source.color );
        this.roughness = source.roughness;
        this.metalness = source.metalness;

        this.map = source.map;

        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;

        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;

        this.emissive.copy( source.emissive );
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;

        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;

        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy( source.normalScale );

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        this.roughnessMap = source.roughnessMap;

        this.metalnessMap = source.metalnessMap;

        this.alphaMap = source.alphaMap;

        this.envMap = source.envMap;
        this.envMapIntensity = source.envMapIntensity;

        this.refractionRatio = source.refractionRatio;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        this.vertexTangents = source.vertexTangents;

        return this;

    };

    /**
     * parameters = {
     *  clearcoat: <float>,
     *  clearcoatMap: new THREE.Texture( <Image> ),
     *  clearcoatRoughness: <float>,
     *  clearcoatRoughnessMap: new THREE.Texture( <Image> ),
     *  clearcoatNormalScale: <Vector2>,
     *  clearcoatNormalMap: new THREE.Texture( <Image> ),
     *
     *  reflectivity: <float>,
     *  ior: <float>,
     *
     *  sheen: <Color>,
     *
     *  transmission: <float>,
     *  transmissionMap: new THREE.Texture( <Image> )
     * }
     */

    function MeshPhysicalMaterial( parameters ) {

        MeshStandardMaterial.call( this );

        this.defines = {

                'STANDARD': '',
                'PHYSICAL': ''

        };

        this.type = 'MeshPhysicalMaterial';

        this.clearcoat = 0.0;
        this.clearcoatMap = null;
        this.clearcoatRoughness = 0.0;
        this.clearcoatRoughnessMap = null;
        this.clearcoatNormalScale = new Vector2( 1, 1 );
        this.clearcoatNormalMap = null;

        this.reflectivity = 0.5; // maps to F0 = 0.04

        Object.defineProperty( this, 'ior', {
                get: function () {

                        return ( 1 + 0.4 * this.reflectivity ) / ( 1 - 0.4 * this.reflectivity );

                },
                set: function ( ior ) {

                        this.reflectivity = MathUtils.clamp( 2.5 * ( ior - 1 ) / ( ior + 1 ), 0, 1 );

                }
        } );

        this.sheen = null; // null will disable sheen bsdf

        this.transmission = 0.0;
        this.transmissionMap = null;

        this.setValues( parameters );

    }

    MeshPhysicalMaterial.prototype = Object.create( MeshStandardMaterial.prototype );
    MeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial;

    MeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true;

    MeshPhysicalMaterial.prototype.copy = function ( source ) {

        MeshStandardMaterial.prototype.copy.call( this, source );

        this.defines = {

                'STANDARD': '',
                'PHYSICAL': ''

        };

        this.clearcoat = source.clearcoat;
        this.clearcoatMap = source.clearcoatMap;
        this.clearcoatRoughness = source.clearcoatRoughness;
        this.clearcoatRoughnessMap = source.clearcoatRoughnessMap;
        this.clearcoatNormalMap = source.clearcoatNormalMap;
        this.clearcoatNormalScale.copy( source.clearcoatNormalScale );

        this.reflectivity = source.reflectivity;

        if ( source.sheen ) {

                this.sheen = ( this.sheen || new Color() ).copy( source.sheen );

        } else {

                this.sheen = null;

        }

        this.transmission = source.transmission;
        this.transmissionMap = source.transmissionMap;

        return this;

    };

    /**
     * parameters = {
     *  color: <hex>,
     *  specular: <hex>,
     *  shininess: <float>,
     *  opacity: <float>,
     *
     *  map: new THREE.Texture( <Image> ),
     *
     *  lightMap: new THREE.Texture( <Image> ),
     *  lightMapIntensity: <float>
     *
     *  aoMap: new THREE.Texture( <Image> ),
     *  aoMapIntensity: <float>
     *
     *  emissive: <hex>,
     *  emissiveIntensity: <float>
     *  emissiveMap: new THREE.Texture( <Image> ),
     *
     *  bumpMap: new THREE.Texture( <Image> ),
     *  bumpScale: <float>,
     *
     *  normalMap: new THREE.Texture( <Image> ),
     *  normalMapType: THREE.TangentSpaceNormalMap,
     *  normalScale: <Vector2>,
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>,
     *
     *  specularMap: new THREE.Texture( <Image> ),
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
     *  combine: THREE.MultiplyOperation,
     *  reflectivity: <float>,
     *  refractionRatio: <float>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function MeshPhongMaterial( parameters ) {

        Material.call( this );

        this.type = 'MeshPhongMaterial';

        this.color = new Color( 0xffffff ); // diffuse
        this.specular = new Color( 0x111111 );
        this.shininess = 30;

        this.map = null;

        this.lightMap = null;
        this.lightMapIntensity = 1.0;

        this.aoMap = null;
        this.aoMapIntensity = 1.0;

        this.emissive = new Color( 0x000000 );
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;

        this.bumpMap = null;
        this.bumpScale = 1;

        this.normalMap = null;
        this.normalMapType = TangentSpaceNormalMap;
        this.normalScale = new Vector2( 1, 1 );

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.specularMap = null;

        this.alphaMap = null;

        this.envMap = null;
        this.combine = MultiplyOperation;
        this.reflectivity = 1;
        this.refractionRatio = 0.98;

        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';

        this.skinning = false;
        this.morphTargets = false;
        this.morphNormals = false;

        this.setValues( parameters );

    }

    MeshPhongMaterial.prototype = Object.create( Material.prototype );
    MeshPhongMaterial.prototype.constructor = MeshPhongMaterial;

    MeshPhongMaterial.prototype.isMeshPhongMaterial = true;

    MeshPhongMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );
        this.specular.copy( source.specular );
        this.shininess = source.shininess;

        this.map = source.map;

        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;

        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;

        this.emissive.copy( source.emissive );
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;

        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;

        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy( source.normalScale );

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        this.specularMap = source.specularMap;

        this.alphaMap = source.alphaMap;

        this.envMap = source.envMap;
        this.combine = source.combine;
        this.reflectivity = source.reflectivity;
        this.refractionRatio = source.refractionRatio;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        return this;

    };

    /**
     * parameters = {
     *  color: <hex>,
     *
     *  map: new THREE.Texture( <Image> ),
     *  gradientMap: new THREE.Texture( <Image> ),
     *
     *  lightMap: new THREE.Texture( <Image> ),
     *  lightMapIntensity: <float>
     *
     *  aoMap: new THREE.Texture( <Image> ),
     *  aoMapIntensity: <float>
     *
     *  emissive: <hex>,
     *  emissiveIntensity: <float>
     *  emissiveMap: new THREE.Texture( <Image> ),
     *
     *  bumpMap: new THREE.Texture( <Image> ),
     *  bumpScale: <float>,
     *
     *  normalMap: new THREE.Texture( <Image> ),
     *  normalMapType: THREE.TangentSpaceNormalMap,
     *  normalScale: <Vector2>,
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>,
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function MeshToonMaterial( parameters ) {

        Material.call( this );

        this.defines = { 'TOON': '' };

        this.type = 'MeshToonMaterial';

        this.color = new Color( 0xffffff );

        this.map = null;
        this.gradientMap = null;

        this.lightMap = null;
        this.lightMapIntensity = 1.0;

        this.aoMap = null;
        this.aoMapIntensity = 1.0;

        this.emissive = new Color( 0x000000 );
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;

        this.bumpMap = null;
        this.bumpScale = 1;

        this.normalMap = null;
        this.normalMapType = TangentSpaceNormalMap;
        this.normalScale = new Vector2( 1, 1 );

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.alphaMap = null;

        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';

        this.skinning = false;
        this.morphTargets = false;
        this.morphNormals = false;

        this.setValues( parameters );

    }

    MeshToonMaterial.prototype = Object.create( Material.prototype );
    MeshToonMaterial.prototype.constructor = MeshToonMaterial;

    MeshToonMaterial.prototype.isMeshToonMaterial = true;

    MeshToonMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        this.map = source.map;
        this.gradientMap = source.gradientMap;

        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;

        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;

        this.emissive.copy( source.emissive );
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;

        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;

        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy( source.normalScale );

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        this.alphaMap = source.alphaMap;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        return this;

    };

    /**
     * parameters = {
     *  opacity: <float>,
     *
     *  bumpMap: new THREE.Texture( <Image> ),
     *  bumpScale: <float>,
     *
     *  normalMap: new THREE.Texture( <Image> ),
     *  normalMapType: THREE.TangentSpaceNormalMap,
     *  normalScale: <Vector2>,
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function MeshNormalMaterial( parameters ) {

        Material.call( this );

        this.type = 'MeshNormalMaterial';

        this.bumpMap = null;
        this.bumpScale = 1;

        this.normalMap = null;
        this.normalMapType = TangentSpaceNormalMap;
        this.normalScale = new Vector2( 1, 1 );

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.wireframe = false;
        this.wireframeLinewidth = 1;

        this.fog = false;

        this.skinning = false;
        this.morphTargets = false;
        this.morphNormals = false;

        this.setValues( parameters );

    }

    MeshNormalMaterial.prototype = Object.create( Material.prototype );
    MeshNormalMaterial.prototype.constructor = MeshNormalMaterial;

    MeshNormalMaterial.prototype.isMeshNormalMaterial = true;

    MeshNormalMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;

        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy( source.normalScale );

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        return this;

    };

    /**
     * parameters = {
     *  color: <hex>,
     *  opacity: <float>,
     *
     *  map: new THREE.Texture( <Image> ),
     *
     *  lightMap: new THREE.Texture( <Image> ),
     *  lightMapIntensity: <float>
     *
     *  aoMap: new THREE.Texture( <Image> ),
     *  aoMapIntensity: <float>
     *
     *  emissive: <hex>,
     *  emissiveIntensity: <float>
     *  emissiveMap: new THREE.Texture( <Image> ),
     *
     *  specularMap: new THREE.Texture( <Image> ),
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
     *  combine: THREE.Multiply,
     *  reflectivity: <float>,
     *  refractionRatio: <float>,
     *
     *  wireframe: <boolean>,
     *  wireframeLinewidth: <float>,
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function MeshLambertMaterial( parameters ) {

        Material.call( this );

        this.type = 'MeshLambertMaterial';

        this.color = new Color( 0xffffff ); // diffuse

        this.map = null;

        this.lightMap = null;
        this.lightMapIntensity = 1.0;

        this.aoMap = null;
        this.aoMapIntensity = 1.0;

        this.emissive = new Color( 0x000000 );
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;

        this.specularMap = null;

        this.alphaMap = null;

        this.envMap = null;
        this.combine = MultiplyOperation;
        this.reflectivity = 1;
        this.refractionRatio = 0.98;

        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';

        this.skinning = false;
        this.morphTargets = false;
        this.morphNormals = false;

        this.setValues( parameters );

    }

    MeshLambertMaterial.prototype = Object.create( Material.prototype );
    MeshLambertMaterial.prototype.constructor = MeshLambertMaterial;

    MeshLambertMaterial.prototype.isMeshLambertMaterial = true;

    MeshLambertMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.color.copy( source.color );

        this.map = source.map;

        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;

        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;

        this.emissive.copy( source.emissive );
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;

        this.specularMap = source.specularMap;

        this.alphaMap = source.alphaMap;

        this.envMap = source.envMap;
        this.combine = source.combine;
        this.reflectivity = source.reflectivity;
        this.refractionRatio = source.refractionRatio;

        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        return this;

    };

    /**
     * parameters = {
     *  color: <hex>,
     *  opacity: <float>,
     *
     *  matcap: new THREE.Texture( <Image> ),
     *
     *  map: new THREE.Texture( <Image> ),
     *
     *  bumpMap: new THREE.Texture( <Image> ),
     *  bumpScale: <float>,
     *
     *  normalMap: new THREE.Texture( <Image> ),
     *  normalMapType: THREE.TangentSpaceNormalMap,
     *  normalScale: <Vector2>,
     *
     *  displacementMap: new THREE.Texture( <Image> ),
     *  displacementScale: <float>,
     *  displacementBias: <float>,
     *
     *  alphaMap: new THREE.Texture( <Image> ),
     *
     *  skinning: <bool>,
     *  morphTargets: <bool>,
     *  morphNormals: <bool>
     * }
     */

    function MeshMatcapMaterial( parameters ) {

        Material.call( this );

        this.defines = { 'MATCAP': '' };

        this.type = 'MeshMatcapMaterial';

        this.color = new Color( 0xffffff ); // diffuse

        this.matcap = null;

        this.map = null;

        this.bumpMap = null;
        this.bumpScale = 1;

        this.normalMap = null;
        this.normalMapType = TangentSpaceNormalMap;
        this.normalScale = new Vector2( 1, 1 );

        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;

        this.alphaMap = null;

        this.skinning = false;
        this.morphTargets = false;
        this.morphNormals = false;

        this.setValues( parameters );

    }

    MeshMatcapMaterial.prototype = Object.create( Material.prototype );
    MeshMatcapMaterial.prototype.constructor = MeshMatcapMaterial;

    MeshMatcapMaterial.prototype.isMeshMatcapMaterial = true;

    MeshMatcapMaterial.prototype.copy = function ( source ) {

        Material.prototype.copy.call( this, source );

        this.defines = { 'MATCAP': '' };

        this.color.copy( source.color );

        this.matcap = source.matcap;

        this.map = source.map;

        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;

        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy( source.normalScale );

        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;

        this.alphaMap = source.alphaMap;

        this.skinning = source.skinning;
        this.morphTargets = source.morphTargets;
        this.morphNormals = source.morphNormals;

        return this;

    };

    /**
     * parameters = {
     *  color: <hex>,
     *  opacity: <float>,
     *
     *  linewidth: <float>,
     *
     *  scale: <float>,
     *  dashSize: <float>,
     *  gapSize: <float>
     * }
     */

    function LineDashedMaterial( parameters ) {

        LineBasicMaterial.call( this );

        this.type = 'LineDashedMaterial';

        this.scale = 1;
        this.dashSize = 3;
        this.gapSize = 1;

        this.setValues( parameters );

    }

    LineDashedMaterial.prototype = Object.create( LineBasicMaterial.prototype );
    LineDashedMaterial.prototype.constructor = LineDashedMaterial;

    LineDashedMaterial.prototype.isLineDashedMaterial = true;

    LineDashedMaterial.prototype.copy = function ( source ) {

        LineBasicMaterial.prototype.copy.call( this, source );

        this.scale = source.scale;
        this.dashSize = source.dashSize;
        this.gapSize = source.gapSize;

        return this;

    };

    var Materials = /*#__PURE__*/Object.freeze({
        __proto__: null,
        ShadowMaterial: ShadowMaterial,
        SpriteMaterial: SpriteMaterial,
        RawShaderMaterial: RawShaderMaterial,
        ShaderMaterial: ShaderMaterial,
        PointsMaterial: PointsMaterial,
        MeshPhysicalMaterial: MeshPhysicalMaterial,
        MeshStandardMaterial: MeshStandardMaterial,
        MeshPhongMaterial: MeshPhongMaterial,
        MeshToonMaterial: MeshToonMaterial,
        MeshNormalMaterial: MeshNormalMaterial,
        MeshLambertMaterial: MeshLambertMaterial,
        MeshDepthMaterial: MeshDepthMaterial,
        MeshDistanceMaterial: MeshDistanceMaterial,
        MeshBasicMaterial: MeshBasicMaterial,
        MeshMatcapMaterial: MeshMatcapMaterial,
        LineDashedMaterial: LineDashedMaterial,
        LineBasicMaterial: LineBasicMaterial,
        Material: Material
    });

    const AnimationUtils = {

        // same as Array.prototype.slice, but also works on typed arrays
        arraySlice: function ( array, from, to ) {

                if ( AnimationUtils.isTypedArray( array ) ) {

                        // in ios9 array.subarray(from, undefined) will return empty array
                        // but array.subarray(from) or array.subarray(from, len) is correct
                        return new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) );

                }

                return array.slice( from, to );

        },

        // converts an array to a specific type
        convertArray: function ( array, type, forceClone ) {

                if ( ! array || // let 'undefined' and 'null' pass
                        ! forceClone && array.constructor === type ) return array;

                if ( typeof type.BYTES_PER_ELEMENT === 'number' ) {

                        return new type( array ); // create typed array

                }

                return Array.prototype.slice.call( array ); // create Array

        },

        isTypedArray: function ( object ) {

                return ArrayBuffer.isView( object ) &&
                        ! ( object instanceof DataView );

        },

        // returns an array by which times and values can be sorted
        getKeyframeOrder: function ( times ) {

                function compareTime( i, j ) {

                        return times[ i ] - times[ j ];

                }

                const n = times.length;
                const result = new Array( n );
                for ( let i = 0; i !== n; ++ i ) result[ i ] = i;

                result.sort( compareTime );

                return result;

        },

        // uses the array previously returned by 'getKeyframeOrder' to sort data
        sortedArray: function ( values, stride, order ) {

                const nValues = values.length;
                const result = new values.constructor( nValues );

                for ( let i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {

                        const srcOffset = order[ i ] * stride;

                        for ( let j = 0; j !== stride; ++ j ) {

                                result[ dstOffset ++ ] = values[ srcOffset + j ];

                        }

                }

                return result;

        },

        // function for parsing AOS keyframe formats
        flattenJSON: function ( jsonKeys, times, values, valuePropertyName ) {

                let i = 1, key = jsonKeys[ 0 ];

                while ( key !== undefined && key[ valuePropertyName ] === undefined ) {

                        key = jsonKeys[ i ++ ];

                }

                if ( key === undefined ) return; // no data

                let value = key[ valuePropertyName ];
                if ( value === undefined ) return; // no data

                if ( Array.isArray( value ) ) {

                        do {

                                value = key[ valuePropertyName ];

                                if ( value !== undefined ) {

                                        times.push( key.time );
                                        values.push.apply( values, value ); // push all elements

                                }

                                key = jsonKeys[ i ++ ];

                        } while ( key !== undefined );

                } else if ( value.toArray !== undefined ) {

                        // ...assume THREE.Math-ish

                        do {

                                value = key[ valuePropertyName ];

                                if ( value !== undefined ) {

                                        times.push( key.time );
                                        value.toArray( values, values.length );

                                }

                                key = jsonKeys[ i ++ ];

                        } while ( key !== undefined );

                } else {

                        // otherwise push as-is

                        do {

                                value = key[ valuePropertyName ];

                                if ( value !== undefined ) {

                                        times.push( key.time );
                                        values.push( value );

                                }

                                key = jsonKeys[ i ++ ];

                        } while ( key !== undefined );

                }

        },

        subclip: function ( sourceClip, name, startFrame, endFrame, fps = 30 ) {

                const clip = sourceClip.clone();

                clip.name = name;

                const tracks = [];

                for ( let i = 0; i < clip.tracks.length; ++ i ) {

                        const track = clip.tracks[ i ];
                        const valueSize = track.getValueSize();

                        const times = [];
                        const values = [];

                        for ( let j = 0; j < track.times.length; ++ j ) {

                                const frame = track.times[ j ] * fps;

                                if ( frame < startFrame || frame >= endFrame ) continue;

                                times.push( track.times[ j ] );

                                for ( let k = 0; k < valueSize; ++ k ) {

                                        values.push( track.values[ j * valueSize + k ] );

                                }

                        }

                        if ( times.length === 0 ) continue;

                        track.times = AnimationUtils.convertArray( times, track.times.constructor );
                        track.values = AnimationUtils.convertArray( values, track.values.constructor );

                        tracks.push( track );

                }

                clip.tracks = tracks;

                // find minimum .times value across all tracks in the trimmed clip

                let minStartTime = Infinity;

                for ( let i = 0; i < clip.tracks.length; ++ i ) {

                        if ( minStartTime > clip.tracks[ i ].times[ 0 ] ) {

                                minStartTime = clip.tracks[ i ].times[ 0 ];

                        }

                }

                // shift all tracks such that clip begins at t=0

                for ( let i = 0; i < clip.tracks.length; ++ i ) {

                        clip.tracks[ i ].shift( - 1 * minStartTime );

                }

                clip.resetDuration();

                return clip;

        },

        makeClipAdditive: function ( targetClip, referenceFrame = 0, referenceClip = targetClip, fps = 30 ) {

                if ( fps <= 0 ) fps = 30;

                const numTracks = referenceClip.tracks.length;
                const referenceTime = referenceFrame / fps;

                // Make each track's values relative to the values at the reference frame
                for ( let i = 0; i < numTracks; ++ i ) {

                        const referenceTrack = referenceClip.tracks[ i ];
                        const referenceTrackType = referenceTrack.ValueTypeName;

                        // Skip this track if it's non-numeric
                        if ( referenceTrackType === 'bool' || referenceTrackType === 'string' ) continue;

                        // Find the track in the target clip whose name and type matches the reference track
                        const targetTrack = targetClip.tracks.find( function ( track ) {

                                return track.name === referenceTrack.name
                                        && track.ValueTypeName === referenceTrackType;

                        } );

                        if ( targetTrack === undefined ) continue;

                        let referenceOffset = 0;
                        const referenceValueSize = referenceTrack.getValueSize();

                        if ( referenceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {

                                referenceOffset = referenceValueSize / 3;

                        }

                        let targetOffset = 0;
                        const targetValueSize = targetTrack.getValueSize();

                        if ( targetTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {

                                targetOffset = targetValueSize / 3;

                        }

                        const lastIndex = referenceTrack.times.length - 1;
                        let referenceValue;

                        // Find the value to subtract out of the track
                        if ( referenceTime <= referenceTrack.times[ 0 ] ) {

                                // Reference frame is earlier than the first keyframe, so just use the first keyframe
                                const startIndex = referenceOffset;
                                const endIndex = referenceValueSize - referenceOffset;
                                referenceValue = AnimationUtils.arraySlice( referenceTrack.values, startIndex, endIndex );

                        } else if ( referenceTime >= referenceTrack.times[ lastIndex ] ) {

                                // Reference frame is after the last keyframe, so just use the last keyframe
                                const startIndex = lastIndex * referenceValueSize + referenceOffset;
                                const endIndex = startIndex + referenceValueSize - referenceOffset;
                                referenceValue = AnimationUtils.arraySlice( referenceTrack.values, startIndex, endIndex );

                        } else {

                                // Interpolate to the reference value
                                const interpolant = referenceTrack.createInterpolant();
                                const startIndex = referenceOffset;
                                const endIndex = referenceValueSize - referenceOffset;
                                interpolant.evaluate( referenceTime );
                                referenceValue = AnimationUtils.arraySlice( interpolant.resultBuffer, startIndex, endIndex );

                        }

                        // Conjugate the quaternion
                        if ( referenceTrackType === 'quaternion' ) {

                                const referenceQuat = new Quaternion().fromArray( referenceValue ).normalize().conjugate();
                                referenceQuat.toArray( referenceValue );

                        }

                        // Subtract the reference value from all of the track values

                        const numTimes = targetTrack.times.length;
                        for ( let j = 0; j < numTimes; ++ j ) {

                                const valueStart = j * targetValueSize + targetOffset;

                                if ( referenceTrackType === 'quaternion' ) {

                                        // Multiply the conjugate for quaternion track types
                                        Quaternion.multiplyQuaternionsFlat(
                                                targetTrack.values,
                                                valueStart,
                                                referenceValue,
                                                0,
                                                targetTrack.values,
                                                valueStart
                                        );

                                } else {

                                        const valueEnd = targetValueSize - targetOffset * 2;

                                        // Subtract each value for all other numeric track types
                                        for ( let k = 0; k < valueEnd; ++ k ) {

                                                targetTrack.values[ valueStart + k ] -= referenceValue[ k ];

                                        }

                                }

                        }

                }

                targetClip.blendMode = AdditiveAnimationBlendMode;

                return targetClip;

        }

    };

    /**
     * Abstract base class of interpolants over parametric samples.
     *
     * The parameter domain is one dimensional, typically the time or a path
     * along a curve defined by the data.
     *
     * The sample values can have any dimensionality and derived classes may
     * apply special interpretations to the data.
     *
     * This class provides the interval seek in a Template Method, deferring
     * the actual interpolation to derived classes.
     *
     * Time complexity is O(1) for linear access crossing at most two points
     * and O(log N) for random access, where N is the number of positions.
     *
     * References:
     *
     *          http://www.oodesign.com/template-method-pattern.html
     *
     */

    function Interpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {

        this.parameterPositions = parameterPositions;
        this._cachedIndex = 0;

        this.resultBuffer = resultBuffer !== undefined ?
                resultBuffer : new sampleValues.constructor( sampleSize );
        this.sampleValues = sampleValues;
        this.valueSize = sampleSize;

    }

    Object.assign( Interpolant.prototype, {

        evaluate: function ( t ) {

                const pp = this.parameterPositions;
                let i1 = this._cachedIndex,
                        t1 = pp[ i1 ],
                        t0 = pp[ i1 - 1 ];

                validate_interval: {

                        seek: {

                                let right;

                                linear_scan: {

                                        //- See http://jsperf.com/comparison-to-undefined/3
                                        //- slower code:
                                        //-
                                        //-                             if ( t >= t1 || t1 === undefined ) {
                                        forward_scan: if ( ! ( t < t1 ) ) {

                                                for ( let giveUpAt = i1 + 2; ; ) {

                                                        if ( t1 === undefined ) {

                                                                if ( t < t0 ) break forward_scan;

                                                                // after end

                                                                i1 = pp.length;
                                                                this._cachedIndex = i1;
                                                                return this.afterEnd_( i1 - 1, t, t0 );

                                                        }

                                                        if ( i1 === giveUpAt ) break; // this loop

                                                        t0 = t1;
                                                        t1 = pp[ ++ i1 ];

                                                        if ( t < t1 ) {

                                                                // we have arrived at the sought interval
                                                                break seek;

                                                        }

                                                }

                                                // prepare binary search on the right side of the index
                                                right = pp.length;
                                                break linear_scan;

                                        }

                                        //- slower code:
                                        //-                                     if ( t < t0 || t0 === undefined ) {
                                        if ( ! ( t >= t0 ) ) {

                                                // looping?

                                                const t1global = pp[ 1 ];

                                                if ( t < t1global ) {

                                                        i1 = 2; // + 1, using the scan for the details
                                                        t0 = t1global;

                                                }

                                                // linear reverse scan

                                                for ( let giveUpAt = i1 - 2; ; ) {

                                                        if ( t0 === undefined ) {

                                                                // before start

                                                                this._cachedIndex = 0;
                                                                return this.beforeStart_( 0, t, t1 );

                                                        }

                                                        if ( i1 === giveUpAt ) break; // this loop

                                                        t1 = t0;
                                                        t0 = pp[ -- i1 - 1 ];

                                                        if ( t >= t0 ) {

                                                                // we have arrived at the sought interval
                                                                break seek;

                                                        }

                                                }

                                                // prepare binary search on the left side of the index
                                                right = i1;
                                                i1 = 0;
                                                break linear_scan;

                                        }

                                        // the interval is valid

                                        break validate_interval;

                                } // linear scan

                                // binary search

                                while ( i1 < right ) {

                                        const mid = ( i1 + right ) >>> 1;

                                        if ( t < pp[ mid ] ) {

                                                right = mid;

                                        } else {

                                                i1 = mid + 1;

                                        }

                                }

                                t1 = pp[ i1 ];
                                t0 = pp[ i1 - 1 ];

                                // check boundary cases, again

                                if ( t0 === undefined ) {

                                        this._cachedIndex = 0;
                                        return this.beforeStart_( 0, t, t1 );

                                }

                                if ( t1 === undefined ) {

                                        i1 = pp.length;
                                        this._cachedIndex = i1;
                                        return this.afterEnd_( i1 - 1, t0, t );

                                }

                        } // seek

                        this._cachedIndex = i1;

                        this.intervalChanged_( i1, t0, t1 );

                } // validate_interval

                return this.interpolate_( i1, t0, t, t1 );

        },

        settings: null, // optional, subclass-specific settings structure
        // Note: The indirection allows central control of many interpolants.

        // --- Protected interface

        DefaultSettings_: {},

        getSettings_: function () {

                return this.settings || this.DefaultSettings_;

        },

        copySampleValue_: function ( index ) {

                // copies a sample value to the result buffer

                const result = this.resultBuffer,
                        values = this.sampleValues,
                        stride = this.valueSize,
                        offset = index * stride;

                for ( let i = 0; i !== stride; ++ i ) {

                        result[ i ] = values[ offset + i ];

                }

                return result;

        },

        // Template methods for derived classes:

        interpolate_: function ( /* i1, t0, t, t1 */ ) {

                throw new Error( 'call to abstract method' );
                // implementations shall return this.resultBuffer

        },

        intervalChanged_: function ( /* i1, t0, t1 */ ) {

                // empty

        }

    } );

    // DECLARE ALIAS AFTER assign prototype
    Object.assign( Interpolant.prototype, {

        //( 0, t, t0 ), returns this.resultBuffer
        beforeStart_: Interpolant.prototype.copySampleValue_,

        //( N-1, tN-1, t ), returns this.resultBuffer
        afterEnd_: Interpolant.prototype.copySampleValue_,

    } );

    /**
     * Fast and simple cubic spline interpolant.
     *
     * It was derived from a Hermitian construction setting the first derivative
     * at each sample position to the linear slope between neighboring positions
     * over their parameter interval.
     */

    function CubicInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {

        Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );

        this._weightPrev = - 0;
        this._offsetPrev = - 0;
        this._weightNext = - 0;
        this._offsetNext = - 0;

    }

    CubicInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {

        constructor: CubicInterpolant,

        DefaultSettings_: {

                endingStart: ZeroCurvatureEnding,
                endingEnd: ZeroCurvatureEnding

        },

        intervalChanged_: function ( i1, t0, t1 ) {

                const pp = this.parameterPositions;
                let iPrev = i1 - 2,
                        iNext = i1 + 1,

                        tPrev = pp[ iPrev ],
                        tNext = pp[ iNext ];

                if ( tPrev === undefined ) {

                        switch ( this.getSettings_().endingStart ) {

                                case ZeroSlopeEnding:

                                        // f'(t0) = 0
                                        iPrev = i1;
                                        tPrev = 2 * t0 - t1;

                                        break;

                                case WrapAroundEnding:

                                        // use the other end of the curve
                                        iPrev = pp.length - 2;
                                        tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];

                                        break;

                                default: // ZeroCurvatureEnding

                                        // f''(t0) = 0 a.k.a. Natural Spline
                                        iPrev = i1;
                                        tPrev = t1;

                        }

                }

                if ( tNext === undefined ) {

                        switch ( this.getSettings_().endingEnd ) {

                                case ZeroSlopeEnding:

                                        // f'(tN) = 0
                                        iNext = i1;
                                        tNext = 2 * t1 - t0;

                                        break;

                                case WrapAroundEnding:

                                        // use the other end of the curve
                                        iNext = 1;
                                        tNext = t1 + pp[ 1 ] - pp[ 0 ];

                                        break;

                                default: // ZeroCurvatureEnding

                                        // f''(tN) = 0, a.k.a. Natural Spline
                                        iNext = i1 - 1;
                                        tNext = t0;

                        }

                }

                const halfDt = ( t1 - t0 ) * 0.5,
                        stride = this.valueSize;

                this._weightPrev = halfDt / ( t0 - tPrev );
                this._weightNext = halfDt / ( tNext - t1 );
                this._offsetPrev = iPrev * stride;
                this._offsetNext = iNext * stride;

        },

        interpolate_: function ( i1, t0, t, t1 ) {

                const result = this.resultBuffer,
                        values = this.sampleValues,
                        stride = this.valueSize,

                        o1 = i1 * stride,               o0 = o1 - stride,
                        oP = this._offsetPrev,  oN = this._offsetNext,
                        wP = this._weightPrev,  wN = this._weightNext,

                        p = ( t - t0 ) / ( t1 - t0 ),
                        pp = p * p,
                        ppp = pp * p;

                // evaluate polynomials

                const sP = - wP * ppp + 2 * wP * pp - wP * p;
                const s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1;
                const s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p;
                const sN = wN * ppp - wN * pp;

                // combine data linearly

                for ( let i = 0; i !== stride; ++ i ) {

                        result[ i ] =
                                        sP * values[ oP + i ] +
                                        s0 * values[ o0 + i ] +
                                        s1 * values[ o1 + i ] +
                                        sN * values[ oN + i ];

                }

                return result;

        }

    } );

    function LinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {

        Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );

    }

    LinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {

        constructor: LinearInterpolant,

        interpolate_: function ( i1, t0, t, t1 ) {

                const result = this.resultBuffer,
                        values = this.sampleValues,
                        stride = this.valueSize,

                        offset1 = i1 * stride,
                        offset0 = offset1 - stride,

                        weight1 = ( t - t0 ) / ( t1 - t0 ),
                        weight0 = 1 - weight1;

                for ( let i = 0; i !== stride; ++ i ) {

                        result[ i ] =
                                        values[ offset0 + i ] * weight0 +
                                        values[ offset1 + i ] * weight1;

                }

                return result;

        }

    } );

    /**
     *
     * Interpolant that evaluates to the sample value at the position preceeding
     * the parameter.
     */

    function DiscreteInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {

        Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );

    }

    DiscreteInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {

        constructor: DiscreteInterpolant,

        interpolate_: function ( i1 /*, t0, t, t1 */ ) {

                return this.copySampleValue_( i1 - 1 );

        }

    } );

    function KeyframeTrack( name, times, values, interpolation ) {

        if ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' );
        if ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name );

        this.name = name;

        this.times = AnimationUtils.convertArray( times, this.TimeBufferType );
        this.values = AnimationUtils.convertArray( values, this.ValueBufferType );

        this.setInterpolation( interpolation || this.DefaultInterpolation );

    }

    // Static methods

    Object.assign( KeyframeTrack, {

        // Serialization (in static context, because of constructor invocation
        // and automatic invocation of .toJSON):

        toJSON: function ( track ) {

                const trackType = track.constructor;

                let json;

                // derived classes can define a static toJSON method
                if ( trackType.toJSON !== undefined ) {

                        json = trackType.toJSON( track );

                } else {

                        // by default, we assume the data can be serialized as-is
                        json = {

                                'name': track.name,
                                'times': AnimationUtils.convertArray( track.times, Array ),
                                'values': AnimationUtils.convertArray( track.values, Array )

                        };

                        const interpolation = track.getInterpolation();

                        if ( interpolation !== track.DefaultInterpolation ) {

                                json.interpolation = interpolation;

                        }

                }

                json.type = track.ValueTypeName; // mandatory

                return json;

        }

    } );

    Object.assign( KeyframeTrack.prototype, {

        constructor: KeyframeTrack,

        TimeBufferType: Float32Array,

        ValueBufferType: Float32Array,

        DefaultInterpolation: InterpolateLinear,

        InterpolantFactoryMethodDiscrete: function ( result ) {

                return new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );

        },

        InterpolantFactoryMethodLinear: function ( result ) {

                return new LinearInterpolant( this.times, this.values, this.getValueSize(), result );

        },

        InterpolantFactoryMethodSmooth: function ( result ) {

                return new CubicInterpolant( this.times, this.values, this.getValueSize(), result );

        },

        setInterpolation: function ( interpolation ) {

                let factoryMethod;

                switch ( interpolation ) {

                        case InterpolateDiscrete:

                                factoryMethod = this.InterpolantFactoryMethodDiscrete;

                                break;

                        case InterpolateLinear:

                                factoryMethod = this.InterpolantFactoryMethodLinear;

                                break;

                        case InterpolateSmooth:

                                factoryMethod = this.InterpolantFactoryMethodSmooth;

                                break;

                }

                if ( factoryMethod === undefined ) {

                        const message = 'unsupported interpolation for ' +
                                this.ValueTypeName + ' keyframe track named ' + this.name;

                        if ( this.createInterpolant === undefined ) {

                                // fall back to default, unless the default itself is messed up
                                if ( interpolation !== this.DefaultInterpolation ) {

                                        this.setInterpolation( this.DefaultInterpolation );

                                } else {

                                        throw new Error( message ); // fatal, in this case

                                }

                        }

                        console.warn( 'THREE.KeyframeTrack:', message );
                        return this;

                }

                this.createInterpolant = factoryMethod;

                return this;

        },

        getInterpolation: function () {

                switch ( this.createInterpolant ) {

                        case this.InterpolantFactoryMethodDiscrete:

                                return InterpolateDiscrete;

                        case this.InterpolantFactoryMethodLinear:

                                return InterpolateLinear;

                        case this.InterpolantFactoryMethodSmooth:

                                return InterpolateSmooth;

                }

        },

        getValueSize: function () {

                return this.values.length / this.times.length;

        },

        // move all keyframes either forwards or backwards in time
        shift: function ( timeOffset ) {

                if ( timeOffset !== 0.0 ) {

                        const times = this.times;

                        for ( let i = 0, n = times.length; i !== n; ++ i ) {

                                times[ i ] += timeOffset;

                        }

                }

                return this;

        },

        // scale all keyframe times by a factor (useful for frame <-> seconds conversions)
        scale: function ( timeScale ) {

                if ( timeScale !== 1.0 ) {

                        const times = this.times;

                        for ( let i = 0, n = times.length; i !== n; ++ i ) {

                                times[ i ] *= timeScale;

                        }

                }

                return this;

        },

        // removes keyframes before and after animation without changing any values within the range [startTime, endTime].
        // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
        trim: function ( startTime, endTime ) {

                const times = this.times,
                        nKeys = times.length;

                let from = 0,
                        to = nKeys - 1;

                while ( from !== nKeys && times[ from ] < startTime ) {

                        ++ from;

                }

                while ( to !== - 1 && times[ to ] > endTime ) {

                        -- to;

                }

                ++ to; // inclusive -> exclusive bound

                if ( from !== 0 || to !== nKeys ) {

                        // empty tracks are forbidden, so keep at least one keyframe
                        if ( from >= to ) {

                                to = Math.max( to, 1 );
                                from = to - 1;

                        }

                        const stride = this.getValueSize();
                        this.times = AnimationUtils.arraySlice( times, from, to );
                        this.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride );

                }

                return this;

        },

        // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
        validate: function () {

                let valid = true;

                const valueSize = this.getValueSize();
                if ( valueSize - Math.floor( valueSize ) !== 0 ) {

                        console.error( 'THREE.KeyframeTrack: Invalid value size in track.', this );
                        valid = false;

                }

                const times = this.times,
                        values = this.values,

                        nKeys = times.length;

                if ( nKeys === 0 ) {

                        console.error( 'THREE.KeyframeTrack: Track is empty.', this );
                        valid = false;

                }

                let prevTime = null;

                for ( let i = 0; i !== nKeys; i ++ ) {

                        const currTime = times[ i ];

                        if ( typeof currTime === 'number' && isNaN( currTime ) ) {

                                console.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime );
                                valid = false;
                                break;

                        }

                        if ( prevTime !== null && prevTime > currTime ) {

                                console.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );
                                valid = false;
                                break;

                        }

                        prevTime = currTime;

                }

                if ( values !== undefined ) {

                        if ( AnimationUtils.isTypedArray( values ) ) {

                                for ( let i = 0, n = values.length; i !== n; ++ i ) {

                                        const value = values[ i ];

                                        if ( isNaN( value ) ) {

                                                console.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value );
                                                valid = false;
                                                break;

                                        }

                                }

                        }

                }

                return valid;

        },

        // removes equivalent sequential keys as common in morph target sequences
        // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
        optimize: function () {

                // times or values may be shared with other tracks, so overwriting is unsafe
                const times = AnimationUtils.arraySlice( this.times ),
                        values = AnimationUtils.arraySlice( this.values ),
                        stride = this.getValueSize(),

                        smoothInterpolation = this.getInterpolation() === InterpolateSmooth,

                        lastIndex = times.length - 1;

                let writeIndex = 1;

                for ( let i = 1; i < lastIndex; ++ i ) {

                        let keep = false;

                        const time = times[ i ];
                        const timeNext = times[ i + 1 ];

                        // remove adjacent keyframes scheduled at the same time

                        if ( time !== timeNext && ( i !== 1 || time !== times[ 0 ] ) ) {

                                if ( ! smoothInterpolation ) {

                                        // remove unnecessary keyframes same as their neighbors

                                        const offset = i * stride,
                                                offsetP = offset - stride,
                                                offsetN = offset + stride;

                                        for ( let j = 0; j !== stride; ++ j ) {

                                                const value = values[ offset + j ];

                                                if ( value !== values[ offsetP + j ] ||
                                                        value !== values[ offsetN + j ] ) {

                                                        keep = true;
                                                        break;

                                                }

                                        }

                                } else {

                                        keep = true;

                                }

                        }

                        // in-place compaction

                        if ( keep ) {

                                if ( i !== writeIndex ) {

                                        times[ writeIndex ] = times[ i ];

                                        const readOffset = i * stride,
                                                writeOffset = writeIndex * stride;

                                        for ( let j = 0; j !== stride; ++ j ) {

                                                values[ writeOffset + j ] = values[ readOffset + j ];

                                        }

                                }

                                ++ writeIndex;

                        }

                }

                // flush last keyframe (compaction looks ahead)

                if ( lastIndex > 0 ) {

                        times[ writeIndex ] = times[ lastIndex ];

                        for ( let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {

                                values[ writeOffset + j ] = values[ readOffset + j ];

                        }

                        ++ writeIndex;

                }

                if ( writeIndex !== times.length ) {

                        this.times = AnimationUtils.arraySlice( times, 0, writeIndex );
                        this.values = AnimationUtils.arraySlice( values, 0, writeIndex * stride );

                } else {

                        this.times = times;
                        this.values = values;

                }

                return this;

        },

        clone: function () {

                const times = AnimationUtils.arraySlice( this.times, 0 );
                const values = AnimationUtils.arraySlice( this.values, 0 );

                const TypedKeyframeTrack = this.constructor;
                const track = new TypedKeyframeTrack( this.name, times, values );

                // Interpolant argument to constructor is not saved, so copy the factory method directly.
                track.createInterpolant = this.createInterpolant;

                return track;

        }

    } );

    /**
     * A Track of Boolean keyframe values.
     */

    function BooleanKeyframeTrack( name, times, values ) {

        KeyframeTrack.call( this, name, times, values );

    }

    BooleanKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {

        constructor: BooleanKeyframeTrack,

        ValueTypeName: 'bool',
        ValueBufferType: Array,

        DefaultInterpolation: InterpolateDiscrete,

        InterpolantFactoryMethodLinear: undefined,
        InterpolantFactoryMethodSmooth: undefined

        // Note: Actually this track could have a optimized / compressed
        // representation of a single value and a custom interpolant that
        // computes "firstValue ^ isOdd( index )".

    } );

    /**
     * A Track of keyframe values that represent color.
     */

    function ColorKeyframeTrack( name, times, values, interpolation ) {

        KeyframeTrack.call( this, name, times, values, interpolation );

    }

    ColorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {

        constructor: ColorKeyframeTrack,

        ValueTypeName: 'color'

        // ValueBufferType is inherited

        // DefaultInterpolation is inherited

        // Note: Very basic implementation and nothing special yet.
        // However, this is the place for color space parameterization.

    } );

    /**
     * A Track of numeric keyframe values.
     */

    function NumberKeyframeTrack( name, times, values, interpolation ) {

        KeyframeTrack.call( this, name, times, values, interpolation );

    }

    NumberKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {

        constructor: NumberKeyframeTrack,

        ValueTypeName: 'number'

        // ValueBufferType is inherited

        // DefaultInterpolation is inherited

    } );

    /**
     * Spherical linear unit quaternion interpolant.
     */

    function QuaternionLinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {

        Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );

    }

    QuaternionLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {

        constructor: QuaternionLinearInterpolant,

        interpolate_: function ( i1, t0, t, t1 ) {

                const result = this.resultBuffer,
                        values = this.sampleValues,
                        stride = this.valueSize,

                        alpha = ( t - t0 ) / ( t1 - t0 );

                let offset = i1 * stride;

                for ( let end = offset + stride; offset !== end; offset += 4 ) {

                        Quaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha );

                }

                return result;

        }

    } );

    /**
     * A Track of quaternion keyframe values.
     */

    function QuaternionKeyframeTrack( name, times, values, interpolation ) {

        KeyframeTrack.call( this, name, times, values, interpolation );

    }

    QuaternionKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {

        constructor: QuaternionKeyframeTrack,

        ValueTypeName: 'quaternion',

        // ValueBufferType is inherited

        DefaultInterpolation: InterpolateLinear,

        InterpolantFactoryMethodLinear: function ( result ) {

                return new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result );

        },

        InterpolantFactoryMethodSmooth: undefined // not yet implemented

    } );

    /**
     * A Track that interpolates Strings
     */

    function StringKeyframeTrack( name, times, values, interpolation ) {

        KeyframeTrack.call( this, name, times, values, interpolation );

    }

    StringKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {

        constructor: StringKeyframeTrack,

        ValueTypeName: 'string',
        ValueBufferType: Array,

        DefaultInterpolation: InterpolateDiscrete,

        InterpolantFactoryMethodLinear: undefined,

        InterpolantFactoryMethodSmooth: undefined

    } );

    /**
     * A Track of vectored keyframe values.
     */

    function VectorKeyframeTrack( name, times, values, interpolation ) {

        KeyframeTrack.call( this, name, times, values, interpolation );

    }

    VectorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {

        constructor: VectorKeyframeTrack,

        ValueTypeName: 'vector'

        // ValueBufferType is inherited

        // DefaultInterpolation is inherited

    } );

    function AnimationClip( name, duration = - 1, tracks, blendMode = NormalAnimationBlendMode ) {

        this.name = name;
        this.tracks = tracks;
        this.duration = duration;
        this.blendMode = blendMode;

        this.uuid = MathUtils.generateUUID();

        // this means it should figure out its duration by scanning the tracks
        if ( this.duration < 0 ) {

                this.resetDuration();

        }

    }

    function getTrackTypeForValueTypeName( typeName ) {

        switch ( typeName.toLowerCase() ) {

                case 'scalar':
                case 'double':
                case 'float':
                case 'number':
                case 'integer':

                        return NumberKeyframeTrack;

                case 'vector':
                case 'vector2':
                case 'vector3':
                case 'vector4':

                        return VectorKeyframeTrack;

                case 'color':

                        return ColorKeyframeTrack;

                case 'quaternion':

                        return QuaternionKeyframeTrack;

                case 'bool':
                case 'boolean':

                        return BooleanKeyframeTrack;

                case 'string':

                        return StringKeyframeTrack;

        }

        throw new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName );

    }

    function parseKeyframeTrack( json ) {

        if ( json.type === undefined ) {

                throw new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' );

        }

        const trackType = getTrackTypeForValueTypeName( json.type );

        if ( json.times === undefined ) {

                const times = [], values = [];

                AnimationUtils.flattenJSON( json.keys, times, values, 'value' );

                json.times = times;
                json.values = values;

        }

        // derived classes can define a static parse method
        if ( trackType.parse !== undefined ) {

                return trackType.parse( json );

        } else {

                // by default, we assume a constructor compatible with the base
                return new trackType( json.name, json.times, json.values, json.interpolation );

        }

    }

    Object.assign( AnimationClip, {

        parse: function ( json ) {

                const tracks = [],
                        jsonTracks = json.tracks,
                        frameTime = 1.0 / ( json.fps || 1.0 );

                for ( let i = 0, n = jsonTracks.length; i !== n; ++ i ) {

                        tracks.push( parseKeyframeTrack( jsonTracks[ i ] ).scale( frameTime ) );

                }

                const clip = new AnimationClip( json.name, json.duration, tracks, json.blendMode );
                clip.uuid = json.uuid;

                return clip;

        },

        toJSON: function ( clip ) {

                const tracks = [],
                        clipTracks = clip.tracks;

                const json = {

                        'name': clip.name,
                        'duration': clip.duration,
                        'tracks': tracks,
                        'uuid': clip.uuid,
                        'blendMode': clip.blendMode

                };

                for ( let i = 0, n = clipTracks.length; i !== n; ++ i ) {

                        tracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) );

                }

                return json;

        },

        CreateFromMorphTargetSequence: function ( name, morphTargetSequence, fps, noLoop ) {

                const numMorphTargets = morphTargetSequence.length;
                const tracks = [];

                for ( let i = 0; i < numMorphTargets; i ++ ) {

                        let times = [];
                        let values = [];

                        times.push(
                                ( i + numMorphTargets - 1 ) % numMorphTargets,
                                i,
                                ( i + 1 ) % numMorphTargets );

                        values.push( 0, 1, 0 );

                        const order = AnimationUtils.getKeyframeOrder( times );
                        times = AnimationUtils.sortedArray( times, 1, order );
                        values = AnimationUtils.sortedArray( values, 1, order );

                        // if there is a key at the first frame, duplicate it as the
                        // last frame as well for perfect loop.
                        if ( ! noLoop && times[ 0 ] === 0 ) {

                                times.push( numMorphTargets );
                                values.push( values[ 0 ] );

                        }

                        tracks.push(
                                new NumberKeyframeTrack(
                                        '.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',
                                        times, values
                                ).scale( 1.0 / fps ) );

                }

                return new AnimationClip( name, - 1, tracks );

        },

        findByName: function ( objectOrClipArray, name ) {

                let clipArray = objectOrClipArray;

                if ( ! Array.isArray( objectOrClipArray ) ) {

                        const o = objectOrClipArray;
                        clipArray = o.geometry && o.geometry.animations || o.animations;

                }

                for ( let i = 0; i < clipArray.length; i ++ ) {

                        if ( clipArray[ i ].name === name ) {

                                return clipArray[ i ];

                        }

                }

                return null;

        },

        CreateClipsFromMorphTargetSequences: function ( morphTargets, fps, noLoop ) {

                const animationToMorphTargets = {};

                // tested with https://regex101.com/ on trick sequences
                // such flamingo_flyA_003, flamingo_run1_003, crdeath0059
                const pattern = /^([\w-]*?)([\d]+)$/;

                // sort morph target names into animation groups based
                // patterns like Walk_001, Walk_002, Run_001, Run_002
                for ( let i = 0, il = morphTargets.length; i < il; i ++ ) {

                        const morphTarget = morphTargets[ i ];
                        const parts = morphTarget.name.match( pattern );

                        if ( parts && parts.length > 1 ) {

                                const name = parts[ 1 ];

                                let animationMorphTargets = animationToMorphTargets[ name ];

                                if ( ! animationMorphTargets ) {

                                        animationToMorphTargets[ name ] = animationMorphTargets = [];

                                }

                                animationMorphTargets.push( morphTarget );

                        }

                }

                const clips = [];

                for ( const name in animationToMorphTargets ) {

                        clips.push( AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );

                }

                return clips;

        },

        // parse the animation.hierarchy format
        parseAnimation: function ( animation, bones ) {

                if ( ! animation ) {

                        console.error( 'THREE.AnimationClip: No animation in JSONLoader data.' );
                        return null;

                }

                const addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {

                        // only return track if there are actually keys.
                        if ( animationKeys.length !== 0 ) {

                                const times = [];
                                const values = [];

                                AnimationUtils.flattenJSON( animationKeys, times, values, propertyName );

                                // empty keys are filtered out, so check again
                                if ( times.length !== 0 ) {

                                        destTracks.push( new trackType( trackName, times, values ) );

                                }

                        }

                };

                const tracks = [];

                const clipName = animation.name || 'default';
                const fps = animation.fps || 30;
                const blendMode = animation.blendMode;

                // automatic length determination in AnimationClip.
                let duration = animation.length || - 1;

                const hierarchyTracks = animation.hierarchy || [];

                for ( let h = 0; h < hierarchyTracks.length; h ++ ) {

                        const animationKeys = hierarchyTracks[ h ].keys;

                        // skip empty tracks
                        if ( ! animationKeys || animationKeys.length === 0 ) continue;

                        // process morph targets
                        if ( animationKeys[ 0 ].morphTargets ) {

                                // figure out all morph targets used in this track
                                const morphTargetNames = {};

                                let k;

                                for ( k = 0; k < animationKeys.length; k ++ ) {

                                        if ( animationKeys[ k ].morphTargets ) {

                                                for ( let m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {

                                                        morphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;

                                                }

                                        }

                                }

                                // create a track for each morph target with all zero
                                // morphTargetInfluences except for the keys in which
                                // the morphTarget is named.
                                for ( const morphTargetName in morphTargetNames ) {

                                        const times = [];
                                        const values = [];

                                        for ( let m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {

                                                const animationKey = animationKeys[ k ];

                                                times.push( animationKey.time );
                                                values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );

                                        }

                                        tracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );

                                }

                                duration = morphTargetNames.length * ( fps || 1.0 );

                        } else {

                                // ...assume skeletal animation

                                const boneName = '.bones[' + bones[ h ].name + ']';

                                addNonemptyTrack(
                                        VectorKeyframeTrack, boneName + '.position',
                                        animationKeys, 'pos', tracks );

                                addNonemptyTrack(
                                        QuaternionKeyframeTrack, boneName + '.quaternion',
                                        animationKeys, 'rot', tracks );

                                addNonemptyTrack(
                                        VectorKeyframeTrack, boneName + '.scale',
                                        animationKeys, 'scl', tracks );

                        }

                }

                if ( tracks.length === 0 ) {

                        return null;

                }

                const clip = new AnimationClip( clipName, duration, tracks, blendMode );

                return clip;

        }

    } );

    Object.assign( AnimationClip.prototype, {

        resetDuration: function () {

                const tracks = this.tracks;
                let duration = 0;

                for ( let i = 0, n = tracks.length; i !== n; ++ i ) {

                        const track = this.tracks[ i ];

                        duration = Math.max( duration, track.times[ track.times.length - 1 ] );

                }

                this.duration = duration;

                return this;

        },

        trim: function () {

                for ( let i = 0; i < this.tracks.length; i ++ ) {

                        this.tracks[ i ].trim( 0, this.duration );

                }

                return this;

        },

        validate: function () {

                let valid = true;

                for ( let i = 0; i < this.tracks.length; i ++ ) {

                        valid = valid && this.tracks[ i ].validate();

                }

                return valid;

        },

        optimize: function () {

                for ( let i = 0; i < this.tracks.length; i ++ ) {

                        this.tracks[ i ].optimize();

                }

                return this;

        },

        clone: function () {

                const tracks = [];

                for ( let i = 0; i < this.tracks.length; i ++ ) {

                        tracks.push( this.tracks[ i ].clone() );

                }

                return new AnimationClip( this.name, this.duration, tracks, this.blendMode );

        },

        toJSON: function () {

                return AnimationClip.toJSON( this );

        }

    } );

    const Cache = {

        enabled: false,

        files: {},

        add: function ( key, file ) {

                if ( this.enabled === false ) return;

                // console.log( 'THREE.Cache', 'Adding key:', key );

                this.files[ key ] = file;

        },

        get: function ( key ) {

                if ( this.enabled === false ) return;

                // console.log( 'THREE.Cache', 'Checking key:', key );

                return this.files[ key ];

        },

        remove: function ( key ) {

                delete this.files[ key ];

        },

        clear: function () {

                this.files = {};

        }

    };

    function LoadingManager( onLoad, onProgress, onError ) {

        const scope = this;

        let isLoading = false;
        let itemsLoaded = 0;
        let itemsTotal = 0;
        let urlModifier = undefined;
        const handlers = [];

        // Refer to #5689 for the reason why we don't set .onStart
        // in the constructor

        this.onStart = undefined;
        this.onLoad = onLoad;
        this.onProgress = onProgress;
        this.onError = onError;

        this.itemStart = function ( url ) {

                itemsTotal ++;

                if ( isLoading === false ) {

                        if ( scope.onStart !== undefined ) {

                                scope.onStart( url, itemsLoaded, itemsTotal );

                        }

                }

                isLoading = true;

        };

        this.itemEnd = function ( url ) {

                itemsLoaded ++;

                if ( scope.onProgress !== undefined ) {

                        scope.onProgress( url, itemsLoaded, itemsTotal );

                }

                if ( itemsLoaded === itemsTotal ) {

                        isLoading = false;

                        if ( scope.onLoad !== undefined ) {

                                scope.onLoad();

                        }

                }

        };

        this.itemError = function ( url ) {

                if ( scope.onError !== undefined ) {

                        scope.onError( url );

                }

        };

        this.resolveURL = function ( url ) {

                if ( urlModifier ) {

                        return urlModifier( url );

                }

                return url;

        };

        this.setURLModifier = function ( transform ) {

                urlModifier = transform;

                return this;

        };

        this.addHandler = function ( regex, loader ) {

                handlers.push( regex, loader );

                return this;

        };

        this.removeHandler = function ( regex ) {

                const index = handlers.indexOf( regex );

                if ( index !== - 1 ) {

                        handlers.splice( index, 2 );

                }

                return this;

        };

        this.getHandler = function ( file ) {

                for ( let i = 0, l = handlers.length; i < l; i += 2 ) {

                        const regex = handlers[ i ];
                        const loader = handlers[ i + 1 ];

                        if ( regex.global ) regex.lastIndex = 0; // see #17920

                        if ( regex.test( file ) ) {

                                return loader;

                        }

                }

                return null;

        };

    }

    const DefaultLoadingManager = new LoadingManager();

    function Loader( manager ) {

        this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;

        this.crossOrigin = 'anonymous';
        this.withCredentials = false;
        this.path = '';
        this.resourcePath = '';
        this.requestHeader = {};

    }

    Object.assign( Loader.prototype, {

        load: function ( /* url, onLoad, onProgress, onError */ ) {},

        loadAsync: function ( url, onProgress ) {

                const scope = this;

                return new Promise( function ( resolve, reject ) {

                        scope.load( url, resolve, onProgress, reject );

                } );

        },

        parse: function ( /* data */ ) {},

        setCrossOrigin: function ( crossOrigin ) {

                this.crossOrigin = crossOrigin;
                return this;

        },

        setWithCredentials: function ( value ) {

                this.withCredentials = value;
                return this;

        },

        setPath: function ( path ) {

                this.path = path;
                return this;

        },

        setResourcePath: function ( resourcePath ) {

                this.resourcePath = resourcePath;
                return this;

        },

        setRequestHeader: function ( requestHeader ) {

                this.requestHeader = requestHeader;
                return this;

        }

    } );

    const loading = {};

    function FileLoader( manager ) {

        Loader.call( this, manager );

    }

    FileLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: FileLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                if ( url === undefined ) url = '';

                if ( this.path !== undefined ) url = this.path + url;

                url = this.manager.resolveURL( url );

                const scope = this;

                const cached = Cache.get( url );

                if ( cached !== undefined ) {

                        scope.manager.itemStart( url );

                        setTimeout( function () {

                                if ( onLoad ) onLoad( cached );

                                scope.manager.itemEnd( url );

                        }, 0 );

                        return cached;

                }

                // Check if request is duplicate

                if ( loading[ url ] !== undefined ) {

                        loading[ url ].push( {

                                onLoad: onLoad,
                                onProgress: onProgress,
                                onError: onError

                        } );

                        return;

                }

                // Check for data: URI
                const dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/;
                const dataUriRegexResult = url.match( dataUriRegex );
                let request;

                // Safari can not handle Data URIs through XMLHttpRequest so process manually
                if ( dataUriRegexResult ) {

                        const mimeType = dataUriRegexResult[ 1 ];
                        const isBase64 = !! dataUriRegexResult[ 2 ];

                        let data = dataUriRegexResult[ 3 ];
                        data = decodeURIComponent( data );

                        if ( isBase64 ) data = atob( data );

                        try {

                                let response;
                                const responseType = ( this.responseType || '' ).toLowerCase();

                                switch ( responseType ) {

                                        case 'arraybuffer':
                                        case 'blob':

                                                const view = new Uint8Array( data.length );

                                                for ( let i = 0; i < data.length; i ++ ) {

                                                        view[ i ] = data.charCodeAt( i );

                                                }

                                                if ( responseType === 'blob' ) {

                                                        response = new Blob( [ view.buffer ], { type: mimeType } );

                                                } else {

                                                        response = view.buffer;

                                                }

                                                break;

                                        case 'document':

                                                const parser = new DOMParser();
                                                response = parser.parseFromString( data, mimeType );

                                                break;

                                        case 'json':

                                                response = JSON.parse( data );

                                                break;

                                        default: // 'text' or other

                                                response = data;

                                                break;

                                }

                                // Wait for next browser tick like standard XMLHttpRequest event dispatching does
                                setTimeout( function () {

                                        if ( onLoad ) onLoad( response );

                                        scope.manager.itemEnd( url );

                                }, 0 );

                        } catch ( error ) {

                                // Wait for next browser tick like standard XMLHttpRequest event dispatching does
                                setTimeout( function () {

                                        if ( onError ) onError( error );

                                        scope.manager.itemError( url );
                                        scope.manager.itemEnd( url );

                                }, 0 );

                        }

                } else {

                        // Initialise array for duplicate requests

                        loading[ url ] = [];

                        loading[ url ].push( {

                                onLoad: onLoad,
                                onProgress: onProgress,
                                onError: onError

                        } );

                        request = new XMLHttpRequest();

                        request.open( 'GET', url, true );

                        request.addEventListener( 'load', function ( event ) {

                                const response = this.response;

                                const callbacks = loading[ url ];

                                delete loading[ url ];

                                if ( this.status === 200 || this.status === 0 ) {

                                        // Some browsers return HTTP Status 0 when using non-http protocol
                                        // e.g. 'file://' or 'data://'. Handle as success.

                                        if ( this.status === 0 ) console.warn( 'THREE.FileLoader: HTTP Status 0 received.' );

                                        // Add to cache only on HTTP success, so that we do not cache
                                        // error response bodies as proper responses to requests.
                                        Cache.add( url, response );

                                        for ( let i = 0, il = callbacks.length; i < il; i ++ ) {

                                                const callback = callbacks[ i ];
                                                if ( callback.onLoad ) callback.onLoad( response );

                                        }

                                        scope.manager.itemEnd( url );

                                } else {

                                        for ( let i = 0, il = callbacks.length; i < il; i ++ ) {

                                                const callback = callbacks[ i ];
                                                if ( callback.onError ) callback.onError( event );

                                        }

                                        scope.manager.itemError( url );
                                        scope.manager.itemEnd( url );

                                }

                        }, false );

                        request.addEventListener( 'progress', function ( event ) {

                                const callbacks = loading[ url ];

                                for ( let i = 0, il = callbacks.length; i < il; i ++ ) {

                                        const callback = callbacks[ i ];
                                        if ( callback.onProgress ) callback.onProgress( event );

                                }

                        }, false );

                        request.addEventListener( 'error', function ( event ) {

                                const callbacks = loading[ url ];

                                delete loading[ url ];

                                for ( let i = 0, il = callbacks.length; i < il; i ++ ) {

                                        const callback = callbacks[ i ];
                                        if ( callback.onError ) callback.onError( event );

                                }

                                scope.manager.itemError( url );
                                scope.manager.itemEnd( url );

                        }, false );

                        request.addEventListener( 'abort', function ( event ) {

                                const callbacks = loading[ url ];

                                delete loading[ url ];

                                for ( let i = 0, il = callbacks.length; i < il; i ++ ) {

                                        const callback = callbacks[ i ];
                                        if ( callback.onError ) callback.onError( event );

                                }

                                scope.manager.itemError( url );
                                scope.manager.itemEnd( url );

                        }, false );

                        if ( this.responseType !== undefined ) request.responseType = this.responseType;
                        if ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials;

                        if ( request.overrideMimeType ) request.overrideMimeType( this.mimeType !== undefined ? this.mimeType : 'text/plain' );

                        for ( const header in this.requestHeader ) {

                                request.setRequestHeader( header, this.requestHeader[ header ] );

                        }

                        request.send( null );

                }

                scope.manager.itemStart( url );

                return request;

        },

        setResponseType: function ( value ) {

                this.responseType = value;
                return this;

        },

        setMimeType: function ( value ) {

                this.mimeType = value;
                return this;

        }

    } );

    function AnimationLoader( manager ) {

        Loader.call( this, manager );

    }

    AnimationLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: AnimationLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const loader = new FileLoader( scope.manager );
                loader.setPath( scope.path );
                loader.setRequestHeader( scope.requestHeader );
                loader.setWithCredentials( scope.withCredentials );
                loader.load( url, function ( text ) {

                        try {

                                onLoad( scope.parse( JSON.parse( text ) ) );

                        } catch ( e ) {

                                if ( onError ) {

                                        onError( e );

                                } else {

                                        console.error( e );

                                }

                                scope.manager.itemError( url );

                        }

                }, onProgress, onError );

        },

        parse: function ( json ) {

                const animations = [];

                for ( let i = 0; i < json.length; i ++ ) {

                        const clip = AnimationClip.parse( json[ i ] );

                        animations.push( clip );

                }

                return animations;

        }

    } );

    /**
     * Abstract Base class to block based textures loader (dds, pvr, ...)
     *
     * Sub classes have to implement the parse() method which will be used in load().
     */

    function CompressedTextureLoader( manager ) {

        Loader.call( this, manager );

    }

    CompressedTextureLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: CompressedTextureLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const images = [];

                const texture = new CompressedTexture();

                const loader = new FileLoader( this.manager );
                loader.setPath( this.path );
                loader.setResponseType( 'arraybuffer' );
                loader.setRequestHeader( this.requestHeader );
                loader.setWithCredentials( scope.withCredentials );

                let loaded = 0;

                function loadTexture( i ) {

                        loader.load( url[ i ], function ( buffer ) {

                                const texDatas = scope.parse( buffer, true );

                                images[ i ] = {
                                        width: texDatas.width,
                                        height: texDatas.height,
                                        format: texDatas.format,
                                        mipmaps: texDatas.mipmaps
                                };

                                loaded += 1;

                                if ( loaded === 6 ) {

                                        if ( texDatas.mipmapCount === 1 ) texture.minFilter = LinearFilter;

                                        texture.image = images;
                                        texture.format = texDatas.format;
                                        texture.needsUpdate = true;

                                        if ( onLoad ) onLoad( texture );

                                }

                        }, onProgress, onError );

                }

                if ( Array.isArray( url ) ) {

                        for ( let i = 0, il = url.length; i < il; ++ i ) {

                                loadTexture( i );

                        }

                } else {

                        // compressed cubemap texture stored in a single DDS file

                        loader.load( url, function ( buffer ) {

                                const texDatas = scope.parse( buffer, true );

                                if ( texDatas.isCubemap ) {

                                        const faces = texDatas.mipmaps.length / texDatas.mipmapCount;

                                        for ( let f = 0; f < faces; f ++ ) {

                                                images[ f ] = { mipmaps: [] };

                                                for ( let i = 0; i < texDatas.mipmapCount; i ++ ) {

                                                        images[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );
                                                        images[ f ].format = texDatas.format;
                                                        images[ f ].width = texDatas.width;
                                                        images[ f ].height = texDatas.height;

                                                }

                                        }

                                        texture.image = images;

                                } else {

                                        texture.image.width = texDatas.width;
                                        texture.image.height = texDatas.height;
                                        texture.mipmaps = texDatas.mipmaps;

                                }

                                if ( texDatas.mipmapCount === 1 ) {

                                        texture.minFilter = LinearFilter;

                                }

                                texture.format = texDatas.format;
                                texture.needsUpdate = true;

                                if ( onLoad ) onLoad( texture );

                        }, onProgress, onError );

                }

                return texture;

        }

    } );

    function ImageLoader( manager ) {

        Loader.call( this, manager );

    }

    ImageLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: ImageLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                if ( this.path !== undefined ) url = this.path + url;

                url = this.manager.resolveURL( url );

                const scope = this;

                const cached = Cache.get( url );

                if ( cached !== undefined ) {

                        scope.manager.itemStart( url );

                        setTimeout( function () {

                                if ( onLoad ) onLoad( cached );

                                scope.manager.itemEnd( url );

                        }, 0 );

                        return cached;

                }

                const image = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'img' );

                function onImageLoad() {

                        image.removeEventListener( 'load', onImageLoad, false );
                        image.removeEventListener( 'error', onImageError, false );

                        Cache.add( url, this );

                        if ( onLoad ) onLoad( this );

                        scope.manager.itemEnd( url );

                }

                function onImageError( event ) {

                        image.removeEventListener( 'load', onImageLoad, false );
                        image.removeEventListener( 'error', onImageError, false );

                        if ( onError ) onError( event );

                        scope.manager.itemError( url );
                        scope.manager.itemEnd( url );

                }

                image.addEventListener( 'load', onImageLoad, false );
                image.addEventListener( 'error', onImageError, false );

                if ( url.substr( 0, 5 ) !== 'data:' ) {

                        if ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;

                }

                scope.manager.itemStart( url );

                image.src = url;

                return image;

        }

    } );

    function CubeTextureLoader( manager ) {

        Loader.call( this, manager );

    }

    CubeTextureLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: CubeTextureLoader,

        load: function ( urls, onLoad, onProgress, onError ) {

                const texture = new CubeTexture();

                const loader = new ImageLoader( this.manager );
                loader.setCrossOrigin( this.crossOrigin );
                loader.setPath( this.path );

                let loaded = 0;

                function loadTexture( i ) {

                        loader.load( urls[ i ], function ( image ) {

                                texture.images[ i ] = image;

                                loaded ++;

                                if ( loaded === 6 ) {

                                        texture.needsUpdate = true;

                                        if ( onLoad ) onLoad( texture );

                                }

                        }, undefined, onError );

                }

                for ( let i = 0; i < urls.length; ++ i ) {

                        loadTexture( i );

                }

                return texture;

        }

    } );

    /**
     * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
     *
     * Sub classes have to implement the parse() method which will be used in load().
     */

    function DataTextureLoader( manager ) {

        Loader.call( this, manager );

    }

    DataTextureLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: DataTextureLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const texture = new DataTexture();

                const loader = new FileLoader( this.manager );
                loader.setResponseType( 'arraybuffer' );
                loader.setRequestHeader( this.requestHeader );
                loader.setPath( this.path );
                loader.setWithCredentials( scope.withCredentials );
                loader.load( url, function ( buffer ) {

                        const texData = scope.parse( buffer );

                        if ( ! texData ) return;

                        if ( texData.image !== undefined ) {

                                texture.image = texData.image;

                        } else if ( texData.data !== undefined ) {

                                texture.image.width = texData.width;
                                texture.image.height = texData.height;
                                texture.image.data = texData.data;

                        }

                        texture.wrapS = texData.wrapS !== undefined ? texData.wrapS : ClampToEdgeWrapping;
                        texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : ClampToEdgeWrapping;

                        texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : LinearFilter;
                        texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : LinearFilter;

                        texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;

                        if ( texData.encoding !== undefined ) {

                                texture.encoding = texData.encoding;

                        }

                        if ( texData.flipY !== undefined ) {

                                texture.flipY = texData.flipY;

                        }

                        if ( texData.format !== undefined ) {

                                texture.format = texData.format;

                        }

                        if ( texData.type !== undefined ) {

                                texture.type = texData.type;

                        }

                        if ( texData.mipmaps !== undefined ) {

                                texture.mipmaps = texData.mipmaps;
                                texture.minFilter = LinearMipmapLinearFilter; // presumably...

                        }

                        if ( texData.mipmapCount === 1 ) {

                                texture.minFilter = LinearFilter;

                        }

                        texture.needsUpdate = true;

                        if ( onLoad ) onLoad( texture, texData );

                }, onProgress, onError );


                return texture;

        }

    } );

    function TextureLoader( manager ) {

        Loader.call( this, manager );

    }

    TextureLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: TextureLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const texture = new Texture();

                const loader = new ImageLoader( this.manager );
                loader.setCrossOrigin( this.crossOrigin );
                loader.setPath( this.path );

                loader.load( url, function ( image ) {

                        texture.image = image;

                        // JPEGs can't have an alpha channel, so memory can be saved by storing them as RGB.
                        const isJPEG = url.search( /\.jpe?g($|\?)/i ) > 0 || url.search( /^data\:image\/jpeg/ ) === 0;

                        texture.format = isJPEG ? RGBFormat : RGBAFormat;
                        texture.needsUpdate = true;

                        if ( onLoad !== undefined ) {

                                onLoad( texture );

                        }

                }, onProgress, onError );

                return texture;

        }

    } );

    /**
     * Extensible curve object.
     *
     * Some common of curve methods:
     * .getPoint( t, optionalTarget ), .getTangent( t, optionalTarget )
     * .getPointAt( u, optionalTarget ), .getTangentAt( u, optionalTarget )
     * .getPoints(), .getSpacedPoints()
     * .getLength()
     * .updateArcLengths()
     *
     * This following curves inherit from THREE.Curve:
     *
     * -- 2D curves --
     * THREE.ArcCurve
     * THREE.CubicBezierCurve
     * THREE.EllipseCurve
     * THREE.LineCurve
     * THREE.QuadraticBezierCurve
     * THREE.SplineCurve
     *
     * -- 3D curves --
     * THREE.CatmullRomCurve3
     * THREE.CubicBezierCurve3
     * THREE.LineCurve3
     * THREE.QuadraticBezierCurve3
     *
     * A series of curves can be represented as a THREE.CurvePath.
     *
     **/

    function Curve() {

        this.type = 'Curve';

        this.arcLengthDivisions = 200;

    }

    Object.assign( Curve.prototype, {

        // Virtual base class method to overwrite and implement in subclasses
        //      - t [0 .. 1]

        getPoint: function ( /* t, optionalTarget */ ) {

                console.warn( 'THREE.Curve: .getPoint() not implemented.' );
                return null;

        },

        // Get point at relative position in curve according to arc length
        // - u [0 .. 1]

        getPointAt: function ( u, optionalTarget ) {

                const t = this.getUtoTmapping( u );
                return this.getPoint( t, optionalTarget );

        },

        // Get sequence of points using getPoint( t )

        getPoints: function ( divisions = 5 ) {

                const points = [];

                for ( let d = 0; d <= divisions; d ++ ) {

                        points.push( this.getPoint( d / divisions ) );

                }

                return points;

        },

        // Get sequence of points using getPointAt( u )

        getSpacedPoints: function ( divisions = 5 ) {

                const points = [];

                for ( let d = 0; d <= divisions; d ++ ) {

                        points.push( this.getPointAt( d / divisions ) );

                }

                return points;

        },

        // Get total curve arc length

        getLength: function () {

                const lengths = this.getLengths();
                return lengths[ lengths.length - 1 ];

        },

        // Get list of cumulative segment lengths

        getLengths: function ( divisions ) {

                if ( divisions === undefined ) divisions = this.arcLengthDivisions;

                if ( this.cacheArcLengths &&
                        ( this.cacheArcLengths.length === divisions + 1 ) &&
                        ! this.needsUpdate ) {

                        return this.cacheArcLengths;

                }

                this.needsUpdate = false;

                const cache = [];
                let current, last = this.getPoint( 0 );
                let sum = 0;

                cache.push( 0 );

                for ( let p = 1; p <= divisions; p ++ ) {

                        current = this.getPoint( p / divisions );
                        sum += current.distanceTo( last );
                        cache.push( sum );
                        last = current;

                }

                this.cacheArcLengths = cache;

                return cache; // { sums: cache, sum: sum }; Sum is in the last element.

        },

        updateArcLengths: function () {

                this.needsUpdate = true;
                this.getLengths();

        },

        // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant

        getUtoTmapping: function ( u, distance ) {

                const arcLengths = this.getLengths();

                let i = 0;
                const il = arcLengths.length;

                let targetArcLength; // The targeted u distance value to get

                if ( distance ) {

                        targetArcLength = distance;

                } else {

                        targetArcLength = u * arcLengths[ il - 1 ];

                }

                // binary search for the index with largest value smaller than target u distance

                let low = 0, high = il - 1, comparison;

                while ( low <= high ) {

                        i = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats

                        comparison = arcLengths[ i ] - targetArcLength;

                        if ( comparison < 0 ) {

                                low = i + 1;

                        } else if ( comparison > 0 ) {

                                high = i - 1;

                        } else {

                                high = i;
                                break;

                                // DONE

                        }

                }

                i = high;

                if ( arcLengths[ i ] === targetArcLength ) {

                        return i / ( il - 1 );

                }

                // we could get finer grain at lengths, or use simple interpolation between two points

                const lengthBefore = arcLengths[ i ];
                const lengthAfter = arcLengths[ i + 1 ];

                const segmentLength = lengthAfter - lengthBefore;

                // determine where we are between the 'before' and 'after' points

                const segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;

                // add that fractional amount to t

                const t = ( i + segmentFraction ) / ( il - 1 );

                return t;

        },

        // Returns a unit vector tangent at t
        // In case any sub curve does not implement its tangent derivation,
        // 2 points a small delta apart will be used to find its gradient
        // which seems to give a reasonable approximation

        getTangent: function ( t, optionalTarget ) {

                const delta = 0.0001;
                let t1 = t - delta;
                let t2 = t + delta;

                // Capping in case of danger

                if ( t1 < 0 ) t1 = 0;
                if ( t2 > 1 ) t2 = 1;

                const pt1 = this.getPoint( t1 );
                const pt2 = this.getPoint( t2 );

                const tangent = optionalTarget || ( ( pt1.isVector2 ) ? new Vector2() : new Vector3() );

                tangent.copy( pt2 ).sub( pt1 ).normalize();

                return tangent;

        },

        getTangentAt: function ( u, optionalTarget ) {

                const t = this.getUtoTmapping( u );
                return this.getTangent( t, optionalTarget );

        },

        computeFrenetFrames: function ( segments, closed ) {

                // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf

                const normal = new Vector3();

                const tangents = [];
                const normals = [];
                const binormals = [];

                const vec = new Vector3();
                const mat = new Matrix4();

                // compute the tangent vectors for each segment on the curve

                for ( let i = 0; i <= segments; i ++ ) {

                        const u = i / segments;

                        tangents[ i ] = this.getTangentAt( u, new Vector3() );
                        tangents[ i ].normalize();

                }

                // select an initial normal vector perpendicular to the first tangent vector,
                // and in the direction of the minimum tangent xyz component

                normals[ 0 ] = new Vector3();
                binormals[ 0 ] = new Vector3();
                let min = Number.MAX_VALUE;
                const tx = Math.abs( tangents[ 0 ].x );
                const ty = Math.abs( tangents[ 0 ].y );
                const tz = Math.abs( tangents[ 0 ].z );

                if ( tx <= min ) {

                        min = tx;
                        normal.set( 1, 0, 0 );

                }

                if ( ty <= min ) {

                        min = ty;
                        normal.set( 0, 1, 0 );

                }

                if ( tz <= min ) {

                        normal.set( 0, 0, 1 );

                }

                vec.crossVectors( tangents[ 0 ], normal ).normalize();

                normals[ 0 ].crossVectors( tangents[ 0 ], vec );
                binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );


                // compute the slowly-varying normal and binormal vectors for each segment on the curve

                for ( let i = 1; i <= segments; i ++ ) {

                        normals[ i ] = normals[ i - 1 ].clone();

                        binormals[ i ] = binormals[ i - 1 ].clone();

                        vec.crossVectors( tangents[ i - 1 ], tangents[ i ] );

                        if ( vec.length() > Number.EPSILON ) {

                                vec.normalize();

                                const theta = Math.acos( MathUtils.clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors

                                normals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );

                        }

                        binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );

                }

                // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same

                if ( closed === true ) {

                        let theta = Math.acos( MathUtils.clamp( normals[ 0 ].dot( normals[ segments ] ), - 1, 1 ) );
                        theta /= segments;

                        if ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ segments ] ) ) > 0 ) {

                                theta = - theta;

                        }

                        for ( let i = 1; i <= segments; i ++ ) {

                                // twist a little...
                                normals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );
                                binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );

                        }

                }

                return {
                        tangents: tangents,
                        normals: normals,
                        binormals: binormals
                };

        },

        clone: function () {

                return new this.constructor().copy( this );

        },

        copy: function ( source ) {

                this.arcLengthDivisions = source.arcLengthDivisions;

                return this;

        },

        toJSON: function () {

                const data = {
                        metadata: {
                                version: 4.5,
                                type: 'Curve',
                                generator: 'Curve.toJSON'
                        }
                };

                data.arcLengthDivisions = this.arcLengthDivisions;
                data.type = this.type;

                return data;

        },

        fromJSON: function ( json ) {

                this.arcLengthDivisions = json.arcLengthDivisions;

                return this;

        }

    } );

    function EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {

        Curve.call( this );

        this.type = 'EllipseCurve';

        this.aX = aX || 0;
        this.aY = aY || 0;

        this.xRadius = xRadius || 1;
        this.yRadius = yRadius || 1;

        this.aStartAngle = aStartAngle || 0;
        this.aEndAngle = aEndAngle || 2 * Math.PI;

        this.aClockwise = aClockwise || false;

        this.aRotation = aRotation || 0;

    }

    EllipseCurve.prototype = Object.create( Curve.prototype );
    EllipseCurve.prototype.constructor = EllipseCurve;

    EllipseCurve.prototype.isEllipseCurve = true;

    EllipseCurve.prototype.getPoint = function ( t, optionalTarget ) {

        const point = optionalTarget || new Vector2();

        const twoPi = Math.PI * 2;
        let deltaAngle = this.aEndAngle - this.aStartAngle;
        const samePoints = Math.abs( deltaAngle ) < Number.EPSILON;

        // ensures that deltaAngle is 0 .. 2 PI
        while ( deltaAngle < 0 ) deltaAngle += twoPi;
        while ( deltaAngle > twoPi ) deltaAngle -= twoPi;

        if ( deltaAngle < Number.EPSILON ) {

                if ( samePoints ) {

                        deltaAngle = 0;

                } else {

                        deltaAngle = twoPi;

                }

        }

        if ( this.aClockwise === true && ! samePoints ) {

                if ( deltaAngle === twoPi ) {

                        deltaAngle = - twoPi;

                } else {

                        deltaAngle = deltaAngle - twoPi;

                }

        }

        const angle = this.aStartAngle + t * deltaAngle;
        let x = this.aX + this.xRadius * Math.cos( angle );
        let y = this.aY + this.yRadius * Math.sin( angle );

        if ( this.aRotation !== 0 ) {

                const cos = Math.cos( this.aRotation );
                const sin = Math.sin( this.aRotation );

                const tx = x - this.aX;
                const ty = y - this.aY;

                // Rotate the point about the center of the ellipse.
                x = tx * cos - ty * sin + this.aX;
                y = tx * sin + ty * cos + this.aY;

        }

        return point.set( x, y );

    };

    EllipseCurve.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.aX = source.aX;
        this.aY = source.aY;

        this.xRadius = source.xRadius;
        this.yRadius = source.yRadius;

        this.aStartAngle = source.aStartAngle;
        this.aEndAngle = source.aEndAngle;

        this.aClockwise = source.aClockwise;

        this.aRotation = source.aRotation;

        return this;

    };


    EllipseCurve.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.aX = this.aX;
        data.aY = this.aY;

        data.xRadius = this.xRadius;
        data.yRadius = this.yRadius;

        data.aStartAngle = this.aStartAngle;
        data.aEndAngle = this.aEndAngle;

        data.aClockwise = this.aClockwise;

        data.aRotation = this.aRotation;

        return data;

    };

    EllipseCurve.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.aX = json.aX;
        this.aY = json.aY;

        this.xRadius = json.xRadius;
        this.yRadius = json.yRadius;

        this.aStartAngle = json.aStartAngle;
        this.aEndAngle = json.aEndAngle;

        this.aClockwise = json.aClockwise;

        this.aRotation = json.aRotation;

        return this;

    };

    function ArcCurve( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {

        EllipseCurve.call( this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );

        this.type = 'ArcCurve';

    }

    ArcCurve.prototype = Object.create( EllipseCurve.prototype );
    ArcCurve.prototype.constructor = ArcCurve;

    ArcCurve.prototype.isArcCurve = true;

    /**
     * Centripetal CatmullRom Curve - which is useful for avoiding
     * cusps and self-intersections in non-uniform catmull rom curves.
     * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
     *
     * curve.type accepts centripetal(default), chordal and catmullrom
     * curve.tension is used for catmullrom which defaults to 0.5
     */


    /*
    Based on an optimized c++ solution in
     - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/
     - http://ideone.com/NoEbVM

    This CubicPoly class could be used for reusing some variables and calculations,
    but for three.js curve use, it could be possible inlined and flatten into a single function call
    which can be placed in CurveUtils.
    */

    function CubicPoly() {

        let c0 = 0, c1 = 0, c2 = 0, c3 = 0;

        /*
         * Compute coefficients for a cubic polynomial
         *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
         * such that
         *   p(0) = x0, p(1) = x1
         *  and
         *   p'(0) = t0, p'(1) = t1.
         */
        function init( x0, x1, t0, t1 ) {

                c0 = x0;
                c1 = t0;
                c2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;
                c3 = 2 * x0 - 2 * x1 + t0 + t1;

        }

        return {

                initCatmullRom: function ( x0, x1, x2, x3, tension ) {

                        init( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );

                },

                initNonuniformCatmullRom: function ( x0, x1, x2, x3, dt0, dt1, dt2 ) {

                        // compute tangents when parameterized in [t1,t2]
                        let t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;
                        let t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;

                        // rescale tangents for parametrization in [0,1]
                        t1 *= dt1;
                        t2 *= dt1;

                        init( x1, x2, t1, t2 );

                },

                calc: function ( t ) {

                        const t2 = t * t;
                        const t3 = t2 * t;
                        return c0 + c1 * t + c2 * t2 + c3 * t3;

                }

        };

    }

    //

    const tmp = new Vector3();
    const px = new CubicPoly(), py = new CubicPoly(), pz = new CubicPoly();

    function CatmullRomCurve3( points = [], closed = false, curveType = 'centripetal', tension = 0.5 ) {

        Curve.call( this );

        this.type = 'CatmullRomCurve3';

        this.points = points;
        this.closed = closed;
        this.curveType = curveType;
        this.tension = tension;

    }

    CatmullRomCurve3.prototype = Object.create( Curve.prototype );
    CatmullRomCurve3.prototype.constructor = CatmullRomCurve3;

    CatmullRomCurve3.prototype.isCatmullRomCurve3 = true;

    CatmullRomCurve3.prototype.getPoint = function ( t, optionalTarget = new Vector3() ) {

        const point = optionalTarget;

        const points = this.points;
        const l = points.length;

        const p = ( l - ( this.closed ? 0 : 1 ) ) * t;
        let intPoint = Math.floor( p );
        let weight = p - intPoint;

        if ( this.closed ) {

                intPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / l ) + 1 ) * l;

        } else if ( weight === 0 && intPoint === l - 1 ) {

                intPoint = l - 2;
                weight = 1;

        }

        let p0, p3; // 4 points (p1 & p2 defined below)

        if ( this.closed || intPoint > 0 ) {

                p0 = points[ ( intPoint - 1 ) % l ];

        } else {

                // extrapolate first point
                tmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );
                p0 = tmp;

        }

        const p1 = points[ intPoint % l ];
        const p2 = points[ ( intPoint + 1 ) % l ];

        if ( this.closed || intPoint + 2 < l ) {

                p3 = points[ ( intPoint + 2 ) % l ];

        } else {

                // extrapolate last point
                tmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );
                p3 = tmp;

        }

        if ( this.curveType === 'centripetal' || this.curveType === 'chordal' ) {

                // init Centripetal / Chordal Catmull-Rom
                const pow = this.curveType === 'chordal' ? 0.5 : 0.25;
                let dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );
                let dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );
                let dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );

                // safety check for repeated points
                if ( dt1 < 1e-4 ) dt1 = 1.0;
                if ( dt0 < 1e-4 ) dt0 = dt1;
                if ( dt2 < 1e-4 ) dt2 = dt1;

                px.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );
                py.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );
                pz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );

        } else if ( this.curveType === 'catmullrom' ) {

                px.initCatmullRom( p0.x, p1.x, p2.x, p3.x, this.tension );
                py.initCatmullRom( p0.y, p1.y, p2.y, p3.y, this.tension );
                pz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, this.tension );

        }

        point.set(
                px.calc( weight ),
                py.calc( weight ),
                pz.calc( weight )
        );

        return point;

    };

    CatmullRomCurve3.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.points = [];

        for ( let i = 0, l = source.points.length; i < l; i ++ ) {

                const point = source.points[ i ];

                this.points.push( point.clone() );

        }

        this.closed = source.closed;
        this.curveType = source.curveType;
        this.tension = source.tension;

        return this;

    };

    CatmullRomCurve3.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.points = [];

        for ( let i = 0, l = this.points.length; i < l; i ++ ) {

                const point = this.points[ i ];
                data.points.push( point.toArray() );

        }

        data.closed = this.closed;
        data.curveType = this.curveType;
        data.tension = this.tension;

        return data;

    };

    CatmullRomCurve3.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.points = [];

        for ( let i = 0, l = json.points.length; i < l; i ++ ) {

                const point = json.points[ i ];
                this.points.push( new Vector3().fromArray( point ) );

        }

        this.closed = json.closed;
        this.curveType = json.curveType;
        this.tension = json.tension;

        return this;

    };

    /**
     * Bezier Curves formulas obtained from
     * http://en.wikipedia.org/wiki/Bézier_curve
     */

    function CatmullRom( t, p0, p1, p2, p3 ) {

        const v0 = ( p2 - p0 ) * 0.5;
        const v1 = ( p3 - p1 ) * 0.5;
        const t2 = t * t;
        const t3 = t * t2;
        return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;

    }

    //

    function QuadraticBezierP0( t, p ) {

        const k = 1 - t;
        return k * k * p;

    }

    function QuadraticBezierP1( t, p ) {

        return 2 * ( 1 - t ) * t * p;

    }

    function QuadraticBezierP2( t, p ) {

        return t * t * p;

    }

    function QuadraticBezier( t, p0, p1, p2 ) {

        return QuadraticBezierP0( t, p0 ) + QuadraticBezierP1( t, p1 ) +
                QuadraticBezierP2( t, p2 );

    }

    //

    function CubicBezierP0( t, p ) {

        const k = 1 - t;
        return k * k * k * p;

    }

    function CubicBezierP1( t, p ) {

        const k = 1 - t;
        return 3 * k * k * t * p;

    }

    function CubicBezierP2( t, p ) {

        return 3 * ( 1 - t ) * t * t * p;

    }

    function CubicBezierP3( t, p ) {

        return t * t * t * p;

    }

    function CubicBezier( t, p0, p1, p2, p3 ) {

        return CubicBezierP0( t, p0 ) + CubicBezierP1( t, p1 ) + CubicBezierP2( t, p2 ) +
                CubicBezierP3( t, p3 );

    }

    function CubicBezierCurve( v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2(), v3 = new Vector2() ) {

        Curve.call( this );

        this.type = 'CubicBezierCurve';

        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;

    }

    CubicBezierCurve.prototype = Object.create( Curve.prototype );
    CubicBezierCurve.prototype.constructor = CubicBezierCurve;

    CubicBezierCurve.prototype.isCubicBezierCurve = true;

    CubicBezierCurve.prototype.getPoint = function ( t, optionalTarget = new Vector2() ) {

        const point = optionalTarget;

        const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;

        point.set(
                CubicBezier( t, v0.x, v1.x, v2.x, v3.x ),
                CubicBezier( t, v0.y, v1.y, v2.y, v3.y )
        );

        return point;

    };

    CubicBezierCurve.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.v0.copy( source.v0 );
        this.v1.copy( source.v1 );
        this.v2.copy( source.v2 );
        this.v3.copy( source.v3 );

        return this;

    };

    CubicBezierCurve.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        data.v3 = this.v3.toArray();

        return data;

    };

    CubicBezierCurve.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.v0.fromArray( json.v0 );
        this.v1.fromArray( json.v1 );
        this.v2.fromArray( json.v2 );
        this.v3.fromArray( json.v3 );

        return this;

    };

    function CubicBezierCurve3( v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3(), v3 = new Vector3() ) {

        Curve.call( this );

        this.type = 'CubicBezierCurve3';

        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;

    }

    CubicBezierCurve3.prototype = Object.create( Curve.prototype );
    CubicBezierCurve3.prototype.constructor = CubicBezierCurve3;

    CubicBezierCurve3.prototype.isCubicBezierCurve3 = true;

    CubicBezierCurve3.prototype.getPoint = function ( t, optionalTarget = new Vector3() ) {

        const point = optionalTarget;

        const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;

        point.set(
                CubicBezier( t, v0.x, v1.x, v2.x, v3.x ),
                CubicBezier( t, v0.y, v1.y, v2.y, v3.y ),
                CubicBezier( t, v0.z, v1.z, v2.z, v3.z )
        );

        return point;

    };

    CubicBezierCurve3.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.v0.copy( source.v0 );
        this.v1.copy( source.v1 );
        this.v2.copy( source.v2 );
        this.v3.copy( source.v3 );

        return this;

    };

    CubicBezierCurve3.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        data.v3 = this.v3.toArray();

        return data;

    };

    CubicBezierCurve3.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.v0.fromArray( json.v0 );
        this.v1.fromArray( json.v1 );
        this.v2.fromArray( json.v2 );
        this.v3.fromArray( json.v3 );

        return this;

    };

    function LineCurve( v1 = new Vector2(), v2 = new Vector2() ) {

        Curve.call( this );

        this.type = 'LineCurve';

        this.v1 = v1;
        this.v2 = v2;

    }

    LineCurve.prototype = Object.create( Curve.prototype );
    LineCurve.prototype.constructor = LineCurve;

    LineCurve.prototype.isLineCurve = true;

    LineCurve.prototype.getPoint = function ( t, optionalTarget = new Vector2() ) {

        const point = optionalTarget;

        if ( t === 1 ) {

                point.copy( this.v2 );

        } else {

                point.copy( this.v2 ).sub( this.v1 );
                point.multiplyScalar( t ).add( this.v1 );

        }

        return point;

    };

    // Line curve is linear, so we can overwrite default getPointAt

    LineCurve.prototype.getPointAt = function ( u, optionalTarget ) {

        return this.getPoint( u, optionalTarget );

    };

    LineCurve.prototype.getTangent = function ( t, optionalTarget ) {

        const tangent = optionalTarget || new Vector2();

        tangent.copy( this.v2 ).sub( this.v1 ).normalize();

        return tangent;

    };

    LineCurve.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.v1.copy( source.v1 );
        this.v2.copy( source.v2 );

        return this;

    };

    LineCurve.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();

        return data;

    };

    LineCurve.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.v1.fromArray( json.v1 );
        this.v2.fromArray( json.v2 );

        return this;

    };

    function LineCurve3( v1 = new Vector3(), v2 = new Vector3() ) {

        Curve.call( this );

        this.type = 'LineCurve3';

        this.v1 = v1;
        this.v2 = v2;

    }

    LineCurve3.prototype = Object.create( Curve.prototype );
    LineCurve3.prototype.constructor = LineCurve3;

    LineCurve3.prototype.isLineCurve3 = true;

    LineCurve3.prototype.getPoint = function ( t, optionalTarget = new Vector3() ) {

        const point = optionalTarget;

        if ( t === 1 ) {

                point.copy( this.v2 );

        } else {

                point.copy( this.v2 ).sub( this.v1 );
                point.multiplyScalar( t ).add( this.v1 );

        }

        return point;

    };

    // Line curve is linear, so we can overwrite default getPointAt

    LineCurve3.prototype.getPointAt = function ( u, optionalTarget ) {

        return this.getPoint( u, optionalTarget );

    };

    LineCurve3.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.v1.copy( source.v1 );
        this.v2.copy( source.v2 );

        return this;

    };

    LineCurve3.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();

        return data;

    };

    LineCurve3.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.v1.fromArray( json.v1 );
        this.v2.fromArray( json.v2 );

        return this;

    };

    function QuadraticBezierCurve( v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2() ) {

        Curve.call( this );

        this.type = 'QuadraticBezierCurve';

        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;

    }

    QuadraticBezierCurve.prototype = Object.create( Curve.prototype );
    QuadraticBezierCurve.prototype.constructor = QuadraticBezierCurve;

    QuadraticBezierCurve.prototype.isQuadraticBezierCurve = true;

    QuadraticBezierCurve.prototype.getPoint = function ( t, optionalTarget = new Vector2() ) {

        const point = optionalTarget;

        const v0 = this.v0, v1 = this.v1, v2 = this.v2;

        point.set(
                QuadraticBezier( t, v0.x, v1.x, v2.x ),
                QuadraticBezier( t, v0.y, v1.y, v2.y )
        );

        return point;

    };

    QuadraticBezierCurve.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.v0.copy( source.v0 );
        this.v1.copy( source.v1 );
        this.v2.copy( source.v2 );

        return this;

    };

    QuadraticBezierCurve.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();

        return data;

    };

    QuadraticBezierCurve.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.v0.fromArray( json.v0 );
        this.v1.fromArray( json.v1 );
        this.v2.fromArray( json.v2 );

        return this;

    };

    function QuadraticBezierCurve3( v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3() ) {

        Curve.call( this );

        this.type = 'QuadraticBezierCurve3';

        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;

    }

    QuadraticBezierCurve3.prototype = Object.create( Curve.prototype );
    QuadraticBezierCurve3.prototype.constructor = QuadraticBezierCurve3;

    QuadraticBezierCurve3.prototype.isQuadraticBezierCurve3 = true;

    QuadraticBezierCurve3.prototype.getPoint = function ( t, optionalTarget = new Vector3() ) {

        const point = optionalTarget;

        const v0 = this.v0, v1 = this.v1, v2 = this.v2;

        point.set(
                QuadraticBezier( t, v0.x, v1.x, v2.x ),
                QuadraticBezier( t, v0.y, v1.y, v2.y ),
                QuadraticBezier( t, v0.z, v1.z, v2.z )
        );

        return point;

    };

    QuadraticBezierCurve3.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.v0.copy( source.v0 );
        this.v1.copy( source.v1 );
        this.v2.copy( source.v2 );

        return this;

    };

    QuadraticBezierCurve3.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();

        return data;

    };

    QuadraticBezierCurve3.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.v0.fromArray( json.v0 );
        this.v1.fromArray( json.v1 );
        this.v2.fromArray( json.v2 );

        return this;

    };

    function SplineCurve( points = [] ) {

        Curve.call( this );

        this.type = 'SplineCurve';

        this.points = points;

    }

    SplineCurve.prototype = Object.create( Curve.prototype );
    SplineCurve.prototype.constructor = SplineCurve;

    SplineCurve.prototype.isSplineCurve = true;

    SplineCurve.prototype.getPoint = function ( t, optionalTarget = new Vector2() ) {

        const point = optionalTarget;

        const points = this.points;
        const p = ( points.length - 1 ) * t;

        const intPoint = Math.floor( p );
        const weight = p - intPoint;

        const p0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];
        const p1 = points[ intPoint ];
        const p2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];
        const p3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];

        point.set(
                CatmullRom( weight, p0.x, p1.x, p2.x, p3.x ),
                CatmullRom( weight, p0.y, p1.y, p2.y, p3.y )
        );

        return point;

    };

    SplineCurve.prototype.copy = function ( source ) {

        Curve.prototype.copy.call( this, source );

        this.points = [];

        for ( let i = 0, l = source.points.length; i < l; i ++ ) {

                const point = source.points[ i ];

                this.points.push( point.clone() );

        }

        return this;

    };

    SplineCurve.prototype.toJSON = function () {

        const data = Curve.prototype.toJSON.call( this );

        data.points = [];

        for ( let i = 0, l = this.points.length; i < l; i ++ ) {

                const point = this.points[ i ];
                data.points.push( point.toArray() );

        }

        return data;

    };

    SplineCurve.prototype.fromJSON = function ( json ) {

        Curve.prototype.fromJSON.call( this, json );

        this.points = [];

        for ( let i = 0, l = json.points.length; i < l; i ++ ) {

                const point = json.points[ i ];
                this.points.push( new Vector2().fromArray( point ) );

        }

        return this;

    };

    var Curves = /*#__PURE__*/Object.freeze({
        __proto__: null,
        ArcCurve: ArcCurve,
        CatmullRomCurve3: CatmullRomCurve3,
        CubicBezierCurve: CubicBezierCurve,
        CubicBezierCurve3: CubicBezierCurve3,
        EllipseCurve: EllipseCurve,
        LineCurve: LineCurve,
        LineCurve3: LineCurve3,
        QuadraticBezierCurve: QuadraticBezierCurve,
        QuadraticBezierCurve3: QuadraticBezierCurve3,
        SplineCurve: SplineCurve
    });

    /**************************************************************
     *  Curved Path - a curve path is simply a array of connected
     *  curves, but retains the api of a curve
     **************************************************************/

    function CurvePath() {

        Curve.call( this );

        this.type = 'CurvePath';

        this.curves = [];
        this.autoClose = false; // Automatically closes the path

    }

    CurvePath.prototype = Object.assign( Object.create( Curve.prototype ), {

        constructor: CurvePath,

        add: function ( curve ) {

                this.curves.push( curve );

        },

        closePath: function () {

                // Add a line curve if start and end of lines are not connected
                const startPoint = this.curves[ 0 ].getPoint( 0 );
                const endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );

                if ( ! startPoint.equals( endPoint ) ) {

                        this.curves.push( new LineCurve( endPoint, startPoint ) );

                }

        },

        // To get accurate point with reference to
        // entire path distance at time t,
        // following has to be done:

        // 1. Length of each sub path have to be known
        // 2. Locate and identify type of curve
        // 3. Get t for the curve
        // 4. Return curve.getPointAt(t')

        getPoint: function ( t ) {

                const d = t * this.getLength();
                const curveLengths = this.getCurveLengths();
                let i = 0;

                // To think about boundaries points.

                while ( i < curveLengths.length ) {

                        if ( curveLengths[ i ] >= d ) {

                                const diff = curveLengths[ i ] - d;
                                const curve = this.curves[ i ];

                                const segmentLength = curve.getLength();
                                const u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;

                                return curve.getPointAt( u );

                        }

                        i ++;

                }

                return null;

                // loop where sum != 0, sum > d , sum+1 <d

        },

        // We cannot use the default THREE.Curve getPoint() with getLength() because in
        // THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
        // getPoint() depends on getLength

        getLength: function () {

                const lens = this.getCurveLengths();
                return lens[ lens.length - 1 ];

        },

        // cacheLengths must be recalculated.
        updateArcLengths: function () {

                this.needsUpdate = true;
                this.cacheLengths = null;
                this.getCurveLengths();

        },

        // Compute lengths and cache them
        // We cannot overwrite getLengths() because UtoT mapping uses it.

        getCurveLengths: function () {

                // We use cache values if curves and cache array are same length

                if ( this.cacheLengths && this.cacheLengths.length === this.curves.length ) {

                        return this.cacheLengths;

                }

                // Get length of sub-curve
                // Push sums into cached array

                const lengths = [];
                let sums = 0;

                for ( let i = 0, l = this.curves.length; i < l; i ++ ) {

                        sums += this.curves[ i ].getLength();
                        lengths.push( sums );

                }

                this.cacheLengths = lengths;

                return lengths;

        },

        getSpacedPoints: function ( divisions = 40 ) {

                const points = [];

                for ( let i = 0; i <= divisions; i ++ ) {

                        points.push( this.getPoint( i / divisions ) );

                }

                if ( this.autoClose ) {

                        points.push( points[ 0 ] );

                }

                return points;

        },

        getPoints: function ( divisions = 12 ) {

                const points = [];
                let last;

                for ( let i = 0, curves = this.curves; i < curves.length; i ++ ) {

                        const curve = curves[ i ];
                        const resolution = ( curve && curve.isEllipseCurve ) ? divisions * 2
                                : ( curve && ( curve.isLineCurve || curve.isLineCurve3 ) ) ? 1
                                        : ( curve && curve.isSplineCurve ) ? divisions * curve.points.length
                                                : divisions;

                        const pts = curve.getPoints( resolution );

                        for ( let j = 0; j < pts.length; j ++ ) {

                                const point = pts[ j ];

                                if ( last && last.equals( point ) ) continue; // ensures no consecutive points are duplicates

                                points.push( point );
                                last = point;

                        }

                }

                if ( this.autoClose && points.length > 1 && ! points[ points.length - 1 ].equals( points[ 0 ] ) ) {

                        points.push( points[ 0 ] );

                }

                return points;

        },

        copy: function ( source ) {

                Curve.prototype.copy.call( this, source );

                this.curves = [];

                for ( let i = 0, l = source.curves.length; i < l; i ++ ) {

                        const curve = source.curves[ i ];

                        this.curves.push( curve.clone() );

                }

                this.autoClose = source.autoClose;

                return this;

        },

        toJSON: function () {

                const data = Curve.prototype.toJSON.call( this );

                data.autoClose = this.autoClose;
                data.curves = [];

                for ( let i = 0, l = this.curves.length; i < l; i ++ ) {

                        const curve = this.curves[ i ];
                        data.curves.push( curve.toJSON() );

                }

                return data;

        },

        fromJSON: function ( json ) {

                Curve.prototype.fromJSON.call( this, json );

                this.autoClose = json.autoClose;
                this.curves = [];

                for ( let i = 0, l = json.curves.length; i < l; i ++ ) {

                        const curve = json.curves[ i ];
                        this.curves.push( new Curves[ curve.type ]().fromJSON( curve ) );

                }

                return this;

        }

    } );

    function Path( points ) {

        CurvePath.call( this );

        this.type = 'Path';

        this.currentPoint = new Vector2();

        if ( points ) {

                this.setFromPoints( points );

        }

    }

    Path.prototype = Object.assign( Object.create( CurvePath.prototype ), {

        constructor: Path,

        setFromPoints: function ( points ) {

                this.moveTo( points[ 0 ].x, points[ 0 ].y );

                for ( let i = 1, l = points.length; i < l; i ++ ) {

                        this.lineTo( points[ i ].x, points[ i ].y );

                }

                return this;

        },

        moveTo: function ( x, y ) {

                this.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying?

                return this;

        },

        lineTo: function ( x, y ) {

                const curve = new LineCurve( this.currentPoint.clone(), new Vector2( x, y ) );
                this.curves.push( curve );

                this.currentPoint.set( x, y );

                return this;

        },

        quadraticCurveTo: function ( aCPx, aCPy, aX, aY ) {

                const curve = new QuadraticBezierCurve(
                        this.currentPoint.clone(),
                        new Vector2( aCPx, aCPy ),
                        new Vector2( aX, aY )
                );

                this.curves.push( curve );

                this.currentPoint.set( aX, aY );

                return this;

        },

        bezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {

                const curve = new CubicBezierCurve(
                        this.currentPoint.clone(),
                        new Vector2( aCP1x, aCP1y ),
                        new Vector2( aCP2x, aCP2y ),
                        new Vector2( aX, aY )
                );

                this.curves.push( curve );

                this.currentPoint.set( aX, aY );

                return this;

        },

        splineThru: function ( pts /*Array of Vector*/ ) {

                const npts = [ this.currentPoint.clone() ].concat( pts );

                const curve = new SplineCurve( npts );
                this.curves.push( curve );

                this.currentPoint.copy( pts[ pts.length - 1 ] );

                return this;

        },

        arc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {

                const x0 = this.currentPoint.x;
                const y0 = this.currentPoint.y;

                this.absarc( aX + x0, aY + y0, aRadius,
                        aStartAngle, aEndAngle, aClockwise );

                return this;

        },

        absarc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {

                this.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );

                return this;

        },

        ellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {

                const x0 = this.currentPoint.x;
                const y0 = this.currentPoint.y;

                this.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );

                return this;

        },

        absellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {

                const curve = new EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );

                if ( this.curves.length > 0 ) {

                        // if a previous curve is present, attempt to join
                        const firstPoint = curve.getPoint( 0 );

                        if ( ! firstPoint.equals( this.currentPoint ) ) {

                                this.lineTo( firstPoint.x, firstPoint.y );

                        }

                }

                this.curves.push( curve );

                const lastPoint = curve.getPoint( 1 );
                this.currentPoint.copy( lastPoint );

                return this;

        },

        copy: function ( source ) {

                CurvePath.prototype.copy.call( this, source );

                this.currentPoint.copy( source.currentPoint );

                return this;

        },

        toJSON: function () {

                const data = CurvePath.prototype.toJSON.call( this );

                data.currentPoint = this.currentPoint.toArray();

                return data;

        },

        fromJSON: function ( json ) {

                CurvePath.prototype.fromJSON.call( this, json );

                this.currentPoint.fromArray( json.currentPoint );

                return this;

        }

    } );

    function Shape( points ) {

        Path.call( this, points );

        this.uuid = MathUtils.generateUUID();

        this.type = 'Shape';

        this.holes = [];

    }

    Shape.prototype = Object.assign( Object.create( Path.prototype ), {

        constructor: Shape,

        getPointsHoles: function ( divisions ) {

                const holesPts = [];

                for ( let i = 0, l = this.holes.length; i < l; i ++ ) {

                        holesPts[ i ] = this.holes[ i ].getPoints( divisions );

                }

                return holesPts;

        },

        // get points of shape and holes (keypoints based on segments parameter)

        extractPoints: function ( divisions ) {

                return {

                        shape: this.getPoints( divisions ),
                        holes: this.getPointsHoles( divisions )

                };

        },

        copy: function ( source ) {

                Path.prototype.copy.call( this, source );

                this.holes = [];

                for ( let i = 0, l = source.holes.length; i < l; i ++ ) {

                        const hole = source.holes[ i ];

                        this.holes.push( hole.clone() );

                }

                return this;

        },

        toJSON: function () {

                const data = Path.prototype.toJSON.call( this );

                data.uuid = this.uuid;
                data.holes = [];

                for ( let i = 0, l = this.holes.length; i < l; i ++ ) {

                        const hole = this.holes[ i ];
                        data.holes.push( hole.toJSON() );

                }

                return data;

        },

        fromJSON: function ( json ) {

                Path.prototype.fromJSON.call( this, json );

                this.uuid = json.uuid;
                this.holes = [];

                for ( let i = 0, l = json.holes.length; i < l; i ++ ) {

                        const hole = json.holes[ i ];
                        this.holes.push( new Path().fromJSON( hole ) );

                }

                return this;

        }

    } );

    function Light( color, intensity = 1 ) {

        Object3D.call( this );

        this.type = 'Light';

        this.color = new Color( color );
        this.intensity = intensity;

    }

    Light.prototype = Object.assign( Object.create( Object3D.prototype ), {

        constructor: Light,

        isLight: true,

        copy: function ( source ) {

                Object3D.prototype.copy.call( this, source );

                this.color.copy( source.color );
                this.intensity = source.intensity;

                return this;

        },

        toJSON: function ( meta ) {

                const data = Object3D.prototype.toJSON.call( this, meta );

                data.object.color = this.color.getHex();
                data.object.intensity = this.intensity;

                if ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();

                if ( this.distance !== undefined ) data.object.distance = this.distance;
                if ( this.angle !== undefined ) data.object.angle = this.angle;
                if ( this.decay !== undefined ) data.object.decay = this.decay;
                if ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;

                if ( this.shadow !== undefined ) data.object.shadow = this.shadow.toJSON();

                return data;

        }

    } );

    function HemisphereLight( skyColor, groundColor, intensity ) {

        Light.call( this, skyColor, intensity );

        this.type = 'HemisphereLight';

        this.position.copy( Object3D.DefaultUp );
        this.updateMatrix();

        this.groundColor = new Color( groundColor );

    }

    HemisphereLight.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: HemisphereLight,

        isHemisphereLight: true,

        copy: function ( source ) {

                Light.prototype.copy.call( this, source );

                this.groundColor.copy( source.groundColor );

                return this;

        }

    } );

    function LightShadow( camera ) {

        this.camera = camera;

        this.bias = 0;
        this.normalBias = 0;
        this.radius = 1;

        this.mapSize = new Vector2( 512, 512 );

        this.map = null;
        this.mapPass = null;
        this.matrix = new Matrix4();

        this.autoUpdate = true;
        this.needsUpdate = false;

        this._frustum = new Frustum();
        this._frameExtents = new Vector2( 1, 1 );

        this._viewportCount = 1;

        this._viewports = [

                new Vector4( 0, 0, 1, 1 )

        ];

    }

    Object.assign( LightShadow.prototype, {

        _projScreenMatrix: new Matrix4(),

        _lightPositionWorld: new Vector3(),

        _lookTarget: new Vector3(),

        getViewportCount: function () {

                return this._viewportCount;

        },

        getFrustum: function () {

                return this._frustum;

        },

        updateMatrices: function ( light ) {

                const shadowCamera = this.camera,
                        shadowMatrix = this.matrix,
                        projScreenMatrix = this._projScreenMatrix,
                        lookTarget = this._lookTarget,
                        lightPositionWorld = this._lightPositionWorld;

                lightPositionWorld.setFromMatrixPosition( light.matrixWorld );
                shadowCamera.position.copy( lightPositionWorld );

                lookTarget.setFromMatrixPosition( light.target.matrixWorld );
                shadowCamera.lookAt( lookTarget );
                shadowCamera.updateMatrixWorld();

                projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );
                this._frustum.setFromProjectionMatrix( projScreenMatrix );

                shadowMatrix.set(
                        0.5, 0.0, 0.0, 0.5,
                        0.0, 0.5, 0.0, 0.5,
                        0.0, 0.0, 0.5, 0.5,
                        0.0, 0.0, 0.0, 1.0
                );

                shadowMatrix.multiply( shadowCamera.projectionMatrix );
                shadowMatrix.multiply( shadowCamera.matrixWorldInverse );

        },

        getViewport: function ( viewportIndex ) {

                return this._viewports[ viewportIndex ];

        },

        getFrameExtents: function () {

                return this._frameExtents;

        },

        copy: function ( source ) {

                this.camera = source.camera.clone();

                this.bias = source.bias;
                this.radius = source.radius;

                this.mapSize.copy( source.mapSize );

                return this;

        },

        clone: function () {

                return new this.constructor().copy( this );

        },

        toJSON: function () {

                const object = {};

                if ( this.bias !== 0 ) object.bias = this.bias;
                if ( this.normalBias !== 0 ) object.normalBias = this.normalBias;
                if ( this.radius !== 1 ) object.radius = this.radius;
                if ( this.mapSize.x !== 512 || this.mapSize.y !== 512 ) object.mapSize = this.mapSize.toArray();

                object.camera = this.camera.toJSON( false ).object;
                delete object.camera.matrix;

                return object;

        }

    } );

    function SpotLightShadow() {

        LightShadow.call( this, new PerspectiveCamera( 50, 1, 0.5, 500 ) );

        this.focus = 1;

    }

    SpotLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {

        constructor: SpotLightShadow,

        isSpotLightShadow: true,

        updateMatrices: function ( light ) {

                const camera = this.camera;

                const fov = MathUtils.RAD2DEG * 2 * light.angle * this.focus;
                const aspect = this.mapSize.width / this.mapSize.height;
                const far = light.distance || camera.far;

                if ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {

                        camera.fov = fov;
                        camera.aspect = aspect;
                        camera.far = far;
                        camera.updateProjectionMatrix();

                }

                LightShadow.prototype.updateMatrices.call( this, light );

        }

    } );

    function SpotLight( color, intensity, distance, angle, penumbra, decay ) {

        Light.call( this, color, intensity );

        this.type = 'SpotLight';

        this.position.copy( Object3D.DefaultUp );
        this.updateMatrix();

        this.target = new Object3D();

        Object.defineProperty( this, 'power', {
                get: function () {

                        // intensity = power per solid angle.
                        // ref: equation (17) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
                        return this.intensity * Math.PI;

                },
                set: function ( power ) {

                        // intensity = power per solid angle.
                        // ref: equation (17) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
                        this.intensity = power / Math.PI;

                }
        } );

        this.distance = ( distance !== undefined ) ? distance : 0;
        this.angle = ( angle !== undefined ) ? angle : Math.PI / 3;
        this.penumbra = ( penumbra !== undefined ) ? penumbra : 0;
        this.decay = ( decay !== undefined ) ? decay : 1;       // for physically correct lights, should be 2.

        this.shadow = new SpotLightShadow();

    }

    SpotLight.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: SpotLight,

        isSpotLight: true,

        copy: function ( source ) {

                Light.prototype.copy.call( this, source );

                this.distance = source.distance;
                this.angle = source.angle;
                this.penumbra = source.penumbra;
                this.decay = source.decay;

                this.target = source.target.clone();

                this.shadow = source.shadow.clone();

                return this;

        }

    } );

    function PointLightShadow() {

        LightShadow.call( this, new PerspectiveCamera( 90, 1, 0.5, 500 ) );

        this._frameExtents = new Vector2( 4, 2 );

        this._viewportCount = 6;

        this._viewports = [
                // These viewports map a cube-map onto a 2D texture with the
                // following orientation:
                //
                //  xzXZ
                //   y Y
                //
                // X - Positive x direction
                // x - Negative x direction
                // Y - Positive y direction
                // y - Negative y direction
                // Z - Positive z direction
                // z - Negative z direction

                // positive X
                new Vector4( 2, 1, 1, 1 ),
                // negative X
                new Vector4( 0, 1, 1, 1 ),
                // positive Z
                new Vector4( 3, 1, 1, 1 ),
                // negative Z
                new Vector4( 1, 1, 1, 1 ),
                // positive Y
                new Vector4( 3, 0, 1, 1 ),
                // negative Y
                new Vector4( 1, 0, 1, 1 )
        ];

        this._cubeDirections = [
                new Vector3( 1, 0, 0 ), new Vector3( - 1, 0, 0 ), new Vector3( 0, 0, 1 ),
                new Vector3( 0, 0, - 1 ), new Vector3( 0, 1, 0 ), new Vector3( 0, - 1, 0 )
        ];

        this._cubeUps = [
                new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ),
                new Vector3( 0, 1, 0 ), new Vector3( 0, 0, 1 ), new Vector3( 0, 0, - 1 )
        ];

    }

    PointLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {

        constructor: PointLightShadow,

        isPointLightShadow: true,

        updateMatrices: function ( light, viewportIndex = 0 ) {

                const camera = this.camera,
                        shadowMatrix = this.matrix,
                        lightPositionWorld = this._lightPositionWorld,
                        lookTarget = this._lookTarget,
                        projScreenMatrix = this._projScreenMatrix;

                lightPositionWorld.setFromMatrixPosition( light.matrixWorld );
                camera.position.copy( lightPositionWorld );

                lookTarget.copy( camera.position );
                lookTarget.add( this._cubeDirections[ viewportIndex ] );
                camera.up.copy( this._cubeUps[ viewportIndex ] );
                camera.lookAt( lookTarget );
                camera.updateMatrixWorld();

                shadowMatrix.makeTranslation( - lightPositionWorld.x, - lightPositionWorld.y, - lightPositionWorld.z );

                projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
                this._frustum.setFromProjectionMatrix( projScreenMatrix );

        }

    } );

    function PointLight( color, intensity, distance, decay ) {

        Light.call( this, color, intensity );

        this.type = 'PointLight';

        Object.defineProperty( this, 'power', {
                get: function () {

                        // intensity = power per solid angle.
                        // ref: equation (15) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
                        return this.intensity * 4 * Math.PI;

                },
                set: function ( power ) {

                        // intensity = power per solid angle.
                        // ref: equation (15) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
                        this.intensity = power / ( 4 * Math.PI );

                }
        } );

        this.distance = ( distance !== undefined ) ? distance : 0;
        this.decay = ( decay !== undefined ) ? decay : 1;       // for physically correct lights, should be 2.

        this.shadow = new PointLightShadow();

    }

    PointLight.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: PointLight,

        isPointLight: true,

        copy: function ( source ) {

                Light.prototype.copy.call( this, source );

                this.distance = source.distance;
                this.decay = source.decay;

                this.shadow = source.shadow.clone();

                return this;

        }

    } );

    function OrthographicCamera( left = - 1, right = 1, top = 1, bottom = - 1, near = 0.1, far = 2000 ) {

        Camera$1.call( this );

        this.type = 'OrthographicCamera';

        this.zoom = 1;
        this.view = null;

        this.left = left;
        this.right = right;
        this.top = top;
        this.bottom = bottom;

        this.near = near;
        this.far = far;

        this.updateProjectionMatrix();

    }

    OrthographicCamera.prototype = Object.assign( Object.create( Camera$1.prototype ), {

        constructor: OrthographicCamera,

        isOrthographicCamera: true,

        copy: function ( source, recursive ) {

                Camera$1.prototype.copy.call( this, source, recursive );

                this.left = source.left;
                this.right = source.right;
                this.top = source.top;
                this.bottom = source.bottom;
                this.near = source.near;
                this.far = source.far;

                this.zoom = source.zoom;
                this.view = source.view === null ? null : Object.assign( {}, source.view );

                return this;

        },

        setViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {

                if ( this.view === null ) {

                        this.view = {
                                enabled: true,
                                fullWidth: 1,
                                fullHeight: 1,
                                offsetX: 0,
                                offsetY: 0,
                                width: 1,
                                height: 1
                        };

                }

                this.view.enabled = true;
                this.view.fullWidth = fullWidth;
                this.view.fullHeight = fullHeight;
                this.view.offsetX = x;
                this.view.offsetY = y;
                this.view.width = width;
                this.view.height = height;

                this.updateProjectionMatrix();

        },

        clearViewOffset: function () {

                if ( this.view !== null ) {

                        this.view.enabled = false;

                }

                this.updateProjectionMatrix();

        },

        updateProjectionMatrix: function () {

                const dx = ( this.right - this.left ) / ( 2 * this.zoom );
                const dy = ( this.top - this.bottom ) / ( 2 * this.zoom );
                const cx = ( this.right + this.left ) / 2;
                const cy = ( this.top + this.bottom ) / 2;

                let left = cx - dx;
                let right = cx + dx;
                let top = cy + dy;
                let bottom = cy - dy;

                if ( this.view !== null && this.view.enabled ) {

                        const scaleW = ( this.right - this.left ) / this.view.fullWidth / this.zoom;
                        const scaleH = ( this.top - this.bottom ) / this.view.fullHeight / this.zoom;

                        left += scaleW * this.view.offsetX;
                        right = left + scaleW * this.view.width;
                        top -= scaleH * this.view.offsetY;
                        bottom = top - scaleH * this.view.height;

                }

                this.projectionMatrix.makeOrthographic( left, right, top, bottom, this.near, this.far );

                this.projectionMatrixInverse.copy( this.projectionMatrix ).invert();

        },

        toJSON: function ( meta ) {

                const data = Object3D.prototype.toJSON.call( this, meta );

                data.object.zoom = this.zoom;
                data.object.left = this.left;
                data.object.right = this.right;
                data.object.top = this.top;
                data.object.bottom = this.bottom;
                data.object.near = this.near;
                data.object.far = this.far;

                if ( this.view !== null ) data.object.view = Object.assign( {}, this.view );

                return data;

        }

    } );

    function DirectionalLightShadow() {

        LightShadow.call( this, new OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );

    }

    DirectionalLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {

        constructor: DirectionalLightShadow,

        isDirectionalLightShadow: true,

        updateMatrices: function ( light ) {

                LightShadow.prototype.updateMatrices.call( this, light );

        }

    } );

    function DirectionalLight( color, intensity ) {

        Light.call( this, color, intensity );

        this.type = 'DirectionalLight';

        this.position.copy( Object3D.DefaultUp );
        this.updateMatrix();

        this.target = new Object3D();

        this.shadow = new DirectionalLightShadow();

    }

    DirectionalLight.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: DirectionalLight,

        isDirectionalLight: true,

        copy: function ( source ) {

                Light.prototype.copy.call( this, source );

                this.target = source.target.clone();

                this.shadow = source.shadow.clone();

                return this;

        }

    } );

    function AmbientLight( color, intensity ) {

        Light.call( this, color, intensity );

        this.type = 'AmbientLight';

    }

    AmbientLight.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: AmbientLight,

        isAmbientLight: true

    } );

    function RectAreaLight( color, intensity, width, height ) {

        Light.call( this, color, intensity );

        this.type = 'RectAreaLight';

        this.width = ( width !== undefined ) ? width : 10;
        this.height = ( height !== undefined ) ? height : 10;

    }

    RectAreaLight.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: RectAreaLight,

        isRectAreaLight: true,

        copy: function ( source ) {

                Light.prototype.copy.call( this, source );

                this.width = source.width;
                this.height = source.height;

                return this;

        },

        toJSON: function ( meta ) {

                const data = Light.prototype.toJSON.call( this, meta );

                data.object.width = this.width;
                data.object.height = this.height;

                return data;

        }

    } );

    /**
     * Primary reference:
     *   https://graphics.stanford.edu/papers/envmap/envmap.pdf
     *
     * Secondary reference:
     *   https://www.ppsloan.org/publications/StupidSH36.pdf
     */

    // 3-band SH defined by 9 coefficients

    class SphericalHarmonics3 {

        constructor() {

                Object.defineProperty( this, 'isSphericalHarmonics3', { value: true } );

                this.coefficients = [];

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients.push( new Vector3() );

                }

        }

        set( coefficients ) {

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients[ i ].copy( coefficients[ i ] );

                }

                return this;

        }

        zero() {

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients[ i ].set( 0, 0, 0 );

                }

                return this;

        }

        // get the radiance in the direction of the normal
        // target is a Vector3
        getAt( normal, target ) {

                // normal is assumed to be unit length

                const x = normal.x, y = normal.y, z = normal.z;

                const coeff = this.coefficients;

                // band 0
                target.copy( coeff[ 0 ] ).multiplyScalar( 0.282095 );

                // band 1
                target.addScaledVector( coeff[ 1 ], 0.488603 * y );
                target.addScaledVector( coeff[ 2 ], 0.488603 * z );
                target.addScaledVector( coeff[ 3 ], 0.488603 * x );

                // band 2
                target.addScaledVector( coeff[ 4 ], 1.092548 * ( x * y ) );
                target.addScaledVector( coeff[ 5 ], 1.092548 * ( y * z ) );
                target.addScaledVector( coeff[ 6 ], 0.315392 * ( 3.0 * z * z - 1.0 ) );
                target.addScaledVector( coeff[ 7 ], 1.092548 * ( x * z ) );
                target.addScaledVector( coeff[ 8 ], 0.546274 * ( x * x - y * y ) );

                return target;

        }

        // get the irradiance (radiance convolved with cosine lobe) in the direction of the normal
        // target is a Vector3
        // https://graphics.stanford.edu/papers/envmap/envmap.pdf
        getIrradianceAt( normal, target ) {

                // normal is assumed to be unit length

                const x = normal.x, y = normal.y, z = normal.z;

                const coeff = this.coefficients;

                // band 0
                target.copy( coeff[ 0 ] ).multiplyScalar( 0.886227 ); // π * 0.282095

                // band 1
                target.addScaledVector( coeff[ 1 ], 2.0 * 0.511664 * y ); // ( 2 * π / 3 ) * 0.488603
                target.addScaledVector( coeff[ 2 ], 2.0 * 0.511664 * z );
                target.addScaledVector( coeff[ 3 ], 2.0 * 0.511664 * x );

                // band 2
                target.addScaledVector( coeff[ 4 ], 2.0 * 0.429043 * x * y ); // ( π / 4 ) * 1.092548
                target.addScaledVector( coeff[ 5 ], 2.0 * 0.429043 * y * z );
                target.addScaledVector( coeff[ 6 ], 0.743125 * z * z - 0.247708 ); // ( π / 4 ) * 0.315392 * 3
                target.addScaledVector( coeff[ 7 ], 2.0 * 0.429043 * x * z );
                target.addScaledVector( coeff[ 8 ], 0.429043 * ( x * x - y * y ) ); // ( π / 4 ) * 0.546274

                return target;

        }

        add( sh ) {

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients[ i ].add( sh.coefficients[ i ] );

                }

                return this;

        }

        addScaledSH( sh, s ) {

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients[ i ].addScaledVector( sh.coefficients[ i ], s );

                }

                return this;

        }

        scale( s ) {

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients[ i ].multiplyScalar( s );

                }

                return this;

        }

        lerp( sh, alpha ) {

                for ( let i = 0; i < 9; i ++ ) {

                        this.coefficients[ i ].lerp( sh.coefficients[ i ], alpha );

                }

                return this;

        }

        equals( sh ) {

                for ( let i = 0; i < 9; i ++ ) {

                        if ( ! this.coefficients[ i ].equals( sh.coefficients[ i ] ) ) {

                                return false;

                        }

                }

                return true;

        }

        copy( sh ) {

                return this.set( sh.coefficients );

        }

        clone() {

                return new this.constructor().copy( this );

        }

        fromArray( array, offset = 0 ) {

                const coefficients = this.coefficients;

                for ( let i = 0; i < 9; i ++ ) {

                        coefficients[ i ].fromArray( array, offset + ( i * 3 ) );

                }

                return this;

        }

        toArray( array = [], offset = 0 ) {

                const coefficients = this.coefficients;

                for ( let i = 0; i < 9; i ++ ) {

                        coefficients[ i ].toArray( array, offset + ( i * 3 ) );

                }

                return array;

        }

        // evaluate the basis functions
        // shBasis is an Array[ 9 ]
        static getBasisAt( normal, shBasis ) {

                // normal is assumed to be unit length

                const x = normal.x, y = normal.y, z = normal.z;

                // band 0
                shBasis[ 0 ] = 0.282095;

                // band 1
                shBasis[ 1 ] = 0.488603 * y;
                shBasis[ 2 ] = 0.488603 * z;
                shBasis[ 3 ] = 0.488603 * x;

                // band 2
                shBasis[ 4 ] = 1.092548 * x * y;
                shBasis[ 5 ] = 1.092548 * y * z;
                shBasis[ 6 ] = 0.315392 * ( 3 * z * z - 1 );
                shBasis[ 7 ] = 1.092548 * x * z;
                shBasis[ 8 ] = 0.546274 * ( x * x - y * y );

        }

    }

    function LightProbe( sh, intensity ) {

        Light.call( this, undefined, intensity );

        this.type = 'LightProbe';

        this.sh = ( sh !== undefined ) ? sh : new SphericalHarmonics3();

    }

    LightProbe.prototype = Object.assign( Object.create( Light.prototype ), {

        constructor: LightProbe,

        isLightProbe: true,

        copy: function ( source ) {

                Light.prototype.copy.call( this, source );

                this.sh.copy( source.sh );

                return this;

        },

        fromJSON: function ( json ) {

                this.intensity = json.intensity; // TODO: Move this bit to Light.fromJSON();
                this.sh.fromArray( json.sh );

                return this;

        },

        toJSON: function ( meta ) {

                const data = Light.prototype.toJSON.call( this, meta );

                data.object.sh = this.sh.toArray();

                return data;

        }

    } );

    function MaterialLoader( manager ) {

        Loader.call( this, manager );

        this.textures = {};

    }

    MaterialLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: MaterialLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const loader = new FileLoader( scope.manager );
                loader.setPath( scope.path );
                loader.setRequestHeader( scope.requestHeader );
                loader.setWithCredentials( scope.withCredentials );
                loader.load( url, function ( text ) {

                        try {

                                onLoad( scope.parse( JSON.parse( text ) ) );

                        } catch ( e ) {

                                if ( onError ) {

                                        onError( e );

                                } else {

                                        console.error( e );

                                }

                                scope.manager.itemError( url );

                        }

                }, onProgress, onError );

        },

        parse: function ( json ) {

                const textures = this.textures;

                function getTexture( name ) {

                        if ( textures[ name ] === undefined ) {

                                console.warn( 'THREE.MaterialLoader: Undefined texture', name );

                        }

                        return textures[ name ];

                }

                const material = new Materials[ json.type ]();

                if ( json.uuid !== undefined ) material.uuid = json.uuid;
                if ( json.name !== undefined ) material.name = json.name;
                if ( json.color !== undefined && material.color !== undefined ) material.color.setHex( json.color );
                if ( json.roughness !== undefined ) material.roughness = json.roughness;
                if ( json.metalness !== undefined ) material.metalness = json.metalness;
                if ( json.sheen !== undefined ) material.sheen = new Color().setHex( json.sheen );
                if ( json.emissive !== undefined && material.emissive !== undefined ) material.emissive.setHex( json.emissive );
                if ( json.specular !== undefined && material.specular !== undefined ) material.specular.setHex( json.specular );
                if ( json.shininess !== undefined ) material.shininess = json.shininess;
                if ( json.clearcoat !== undefined ) material.clearcoat = json.clearcoat;
                if ( json.clearcoatRoughness !== undefined ) material.clearcoatRoughness = json.clearcoatRoughness;
                if ( json.fog !== undefined ) material.fog = json.fog;
                if ( json.flatShading !== undefined ) material.flatShading = json.flatShading;
                if ( json.blending !== undefined ) material.blending = json.blending;
                if ( json.combine !== undefined ) material.combine = json.combine;
                if ( json.side !== undefined ) material.side = json.side;
                if ( json.opacity !== undefined ) material.opacity = json.opacity;
                if ( json.transparent !== undefined ) material.transparent = json.transparent;
                if ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;
                if ( json.depthTest !== undefined ) material.depthTest = json.depthTest;
                if ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;
                if ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;

                if ( json.stencilWrite !== undefined ) material.stencilWrite = json.stencilWrite;
                if ( json.stencilWriteMask !== undefined ) material.stencilWriteMask = json.stencilWriteMask;
                if ( json.stencilFunc !== undefined ) material.stencilFunc = json.stencilFunc;
                if ( json.stencilRef !== undefined ) material.stencilRef = json.stencilRef;
                if ( json.stencilFuncMask !== undefined ) material.stencilFuncMask = json.stencilFuncMask;
                if ( json.stencilFail !== undefined ) material.stencilFail = json.stencilFail;
                if ( json.stencilZFail !== undefined ) material.stencilZFail = json.stencilZFail;
                if ( json.stencilZPass !== undefined ) material.stencilZPass = json.stencilZPass;

                if ( json.wireframe !== undefined ) material.wireframe = json.wireframe;
                if ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;
                if ( json.wireframeLinecap !== undefined ) material.wireframeLinecap = json.wireframeLinecap;
                if ( json.wireframeLinejoin !== undefined ) material.wireframeLinejoin = json.wireframeLinejoin;

                if ( json.rotation !== undefined ) material.rotation = json.rotation;

                if ( json.linewidth !== 1 ) material.linewidth = json.linewidth;
                if ( json.dashSize !== undefined ) material.dashSize = json.dashSize;
                if ( json.gapSize !== undefined ) material.gapSize = json.gapSize;
                if ( json.scale !== undefined ) material.scale = json.scale;

                if ( json.polygonOffset !== undefined ) material.polygonOffset = json.polygonOffset;
                if ( json.polygonOffsetFactor !== undefined ) material.polygonOffsetFactor = json.polygonOffsetFactor;
                if ( json.polygonOffsetUnits !== undefined ) material.polygonOffsetUnits = json.polygonOffsetUnits;

                if ( json.skinning !== undefined ) material.skinning = json.skinning;
                if ( json.morphTargets !== undefined ) material.morphTargets = json.morphTargets;
                if ( json.morphNormals !== undefined ) material.morphNormals = json.morphNormals;
                if ( json.dithering !== undefined ) material.dithering = json.dithering;

                if ( json.vertexTangents !== undefined ) material.vertexTangents = json.vertexTangents;

                if ( json.visible !== undefined ) material.visible = json.visible;

                if ( json.toneMapped !== undefined ) material.toneMapped = json.toneMapped;

                if ( json.userData !== undefined ) material.userData = json.userData;

                if ( json.vertexColors !== undefined ) {

                        if ( typeof json.vertexColors === 'number' ) {

                                material.vertexColors = ( json.vertexColors > 0 ) ? true : false;

                        } else {

                                material.vertexColors = json.vertexColors;

                        }

                }

                // Shader Material

                if ( json.uniforms !== undefined ) {

                        for ( const name in json.uniforms ) {

                                const uniform = json.uniforms[ name ];

                                material.uniforms[ name ] = {};

                                switch ( uniform.type ) {

                                        case 't':
                                                material.uniforms[ name ].value = getTexture( uniform.value );
                                                break;

                                        case 'c':
                                                material.uniforms[ name ].value = new Color().setHex( uniform.value );
                                                break;

                                        case 'v2':
                                                material.uniforms[ name ].value = new Vector2().fromArray( uniform.value );
                                                break;

                                        case 'v3':
                                                material.uniforms[ name ].value = new Vector3().fromArray( uniform.value );
                                                break;

                                        case 'v4':
                                                material.uniforms[ name ].value = new Vector4().fromArray( uniform.value );
                                                break;

                                        case 'm3':
                                                material.uniforms[ name ].value = new Matrix3().fromArray( uniform.value );
                                                break;

                                        case 'm4':
                                                material.uniforms[ name ].value = new Matrix4().fromArray( uniform.value );
                                                break;

                                        default:
                                                material.uniforms[ name ].value = uniform.value;

                                }

                        }

                }

                if ( json.defines !== undefined ) material.defines = json.defines;
                if ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;
                if ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;

                if ( json.extensions !== undefined ) {

                        for ( const key in json.extensions ) {

                                material.extensions[ key ] = json.extensions[ key ];

                        }

                }

                // Deprecated

                if ( json.shading !== undefined ) material.flatShading = json.shading === 1; // THREE.FlatShading

                // for PointsMaterial

                if ( json.size !== undefined ) material.size = json.size;
                if ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;

                // maps

                if ( json.map !== undefined ) material.map = getTexture( json.map );
                if ( json.matcap !== undefined ) material.matcap = getTexture( json.matcap );

                if ( json.alphaMap !== undefined ) material.alphaMap = getTexture( json.alphaMap );

                if ( json.bumpMap !== undefined ) material.bumpMap = getTexture( json.bumpMap );
                if ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;

                if ( json.normalMap !== undefined ) material.normalMap = getTexture( json.normalMap );
                if ( json.normalMapType !== undefined ) material.normalMapType = json.normalMapType;
                if ( json.normalScale !== undefined ) {

                        let normalScale = json.normalScale;

                        if ( Array.isArray( normalScale ) === false ) {

                                // Blender exporter used to export a scalar. See #7459

                                normalScale = [ normalScale, normalScale ];

                        }

                        material.normalScale = new Vector2().fromArray( normalScale );

                }

                if ( json.displacementMap !== undefined ) material.displacementMap = getTexture( json.displacementMap );
                if ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;
                if ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;

                if ( json.roughnessMap !== undefined ) material.roughnessMap = getTexture( json.roughnessMap );
                if ( json.metalnessMap !== undefined ) material.metalnessMap = getTexture( json.metalnessMap );

                if ( json.emissiveMap !== undefined ) material.emissiveMap = getTexture( json.emissiveMap );
                if ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;

                if ( json.specularMap !== undefined ) material.specularMap = getTexture( json.specularMap );

                if ( json.envMap !== undefined ) material.envMap = getTexture( json.envMap );
                if ( json.envMapIntensity !== undefined ) material.envMapIntensity = json.envMapIntensity;

                if ( json.reflectivity !== undefined ) material.reflectivity = json.reflectivity;
                if ( json.refractionRatio !== undefined ) material.refractionRatio = json.refractionRatio;

                if ( json.lightMap !== undefined ) material.lightMap = getTexture( json.lightMap );
                if ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;

                if ( json.aoMap !== undefined ) material.aoMap = getTexture( json.aoMap );
                if ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;

                if ( json.gradientMap !== undefined ) material.gradientMap = getTexture( json.gradientMap );

                if ( json.clearcoatMap !== undefined ) material.clearcoatMap = getTexture( json.clearcoatMap );
                if ( json.clearcoatRoughnessMap !== undefined ) material.clearcoatRoughnessMap = getTexture( json.clearcoatRoughnessMap );
                if ( json.clearcoatNormalMap !== undefined ) material.clearcoatNormalMap = getTexture( json.clearcoatNormalMap );
                if ( json.clearcoatNormalScale !== undefined ) material.clearcoatNormalScale = new Vector2().fromArray( json.clearcoatNormalScale );

                if ( json.transmission !== undefined ) material.transmission = json.transmission;
                if ( json.transmissionMap !== undefined ) material.transmissionMap = getTexture( json.transmissionMap );

                return material;

        },

        setTextures: function ( value ) {

                this.textures = value;
                return this;

        }

    } );

    const LoaderUtils = {

        decodeText: function ( array ) {

                if ( typeof TextDecoder !== 'undefined' ) {

                        return new TextDecoder().decode( array );

                }

                // Avoid the String.fromCharCode.apply(null, array) shortcut, which
                // throws a "maximum call stack size exceeded" error for large arrays.

                let s = '';

                for ( let i = 0, il = array.length; i < il; i ++ ) {

                        // Implicitly assumes little-endian.
                        s += String.fromCharCode( array[ i ] );

                }

                try {

                        // merges multi-byte utf-8 characters.

                        return decodeURIComponent( escape( s ) );

                } catch ( e ) { // see #16358

                        return s;

                }

        },

        extractUrlBase: function ( url ) {

                const index = url.lastIndexOf( '/' );

                if ( index === - 1 ) return './';

                return url.substr( 0, index + 1 );

        }

    };

    function InstancedBufferGeometry() {

        BufferGeometry.call( this );

        this.type = 'InstancedBufferGeometry';
        this.instanceCount = Infinity;

    }

    InstancedBufferGeometry.prototype = Object.assign( Object.create( BufferGeometry.prototype ), {

        constructor: InstancedBufferGeometry,

        isInstancedBufferGeometry: true,

        copy: function ( source ) {

                BufferGeometry.prototype.copy.call( this, source );

                this.instanceCount = source.instanceCount;

                return this;

        },

        clone: function () {

                return new this.constructor().copy( this );

        },

        toJSON: function () {

                const data = BufferGeometry.prototype.toJSON.call( this );

                data.instanceCount = this.instanceCount;

                data.isInstancedBufferGeometry = true;

                return data;

        }

    } );

    function InstancedBufferAttribute( array, itemSize, normalized, meshPerAttribute ) {

        if ( typeof ( normalized ) === 'number' ) {

                meshPerAttribute = normalized;

                normalized = false;

                console.error( 'THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.' );

        }

        BufferAttribute.call( this, array, itemSize, normalized );

        this.meshPerAttribute = meshPerAttribute || 1;

    }

    InstancedBufferAttribute.prototype = Object.assign( Object.create( BufferAttribute.prototype ), {

        constructor: InstancedBufferAttribute,

        isInstancedBufferAttribute: true,

        copy: function ( source ) {

                BufferAttribute.prototype.copy.call( this, source );

                this.meshPerAttribute = source.meshPerAttribute;

                return this;

        },

        toJSON: function ()     {

                const data = BufferAttribute.prototype.toJSON.call( this );

                data.meshPerAttribute = this.meshPerAttribute;

                data.isInstancedBufferAttribute = true;

                return data;

        }

    } );

    function BufferGeometryLoader( manager ) {

        Loader.call( this, manager );

    }

    BufferGeometryLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: BufferGeometryLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const loader = new FileLoader( scope.manager );
                loader.setPath( scope.path );
                loader.setRequestHeader( scope.requestHeader );
                loader.setWithCredentials( scope.withCredentials );
                loader.load( url, function ( text ) {

                        try {

                                onLoad( scope.parse( JSON.parse( text ) ) );

                        } catch ( e ) {

                                if ( onError ) {

                                        onError( e );

                                } else {

                                        console.error( e );

                                }

                                scope.manager.itemError( url );

                        }

                }, onProgress, onError );

        },

        parse: function ( json ) {

                const interleavedBufferMap = {};
                const arrayBufferMap = {};

                function getInterleavedBuffer( json, uuid ) {

                        if ( interleavedBufferMap[ uuid ] !== undefined ) return interleavedBufferMap[ uuid ];

                        const interleavedBuffers = json.interleavedBuffers;
                        const interleavedBuffer = interleavedBuffers[ uuid ];

                        const buffer = getArrayBuffer( json, interleavedBuffer.buffer );

                        const array = getTypedArray( interleavedBuffer.type, buffer );
                        const ib = new InterleavedBuffer( array, interleavedBuffer.stride );
                        ib.uuid = interleavedBuffer.uuid;

                        interleavedBufferMap[ uuid ] = ib;

                        return ib;

                }

                function getArrayBuffer( json, uuid ) {

                        if ( arrayBufferMap[ uuid ] !== undefined ) return arrayBufferMap[ uuid ];

                        const arrayBuffers = json.arrayBuffers;
                        const arrayBuffer = arrayBuffers[ uuid ];

                        const ab = new Uint32Array( arrayBuffer ).buffer;

                        arrayBufferMap[ uuid ] = ab;

                        return ab;

                }

                const geometry = json.isInstancedBufferGeometry ? new InstancedBufferGeometry() : new BufferGeometry();

                const index = json.data.index;

                if ( index !== undefined ) {

                        const typedArray = getTypedArray( index.type, index.array );
                        geometry.setIndex( new BufferAttribute( typedArray, 1 ) );

                }

                const attributes = json.data.attributes;

                for ( const key in attributes ) {

                        const attribute = attributes[ key ];
                        let bufferAttribute;

                        if ( attribute.isInterleavedBufferAttribute ) {

                                const interleavedBuffer = getInterleavedBuffer( json.data, attribute.data );
                                bufferAttribute = new InterleavedBufferAttribute( interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized );

                        } else {

                                const typedArray = getTypedArray( attribute.type, attribute.array );
                                const bufferAttributeConstr = attribute.isInstancedBufferAttribute ? InstancedBufferAttribute : BufferAttribute;
                                bufferAttribute = new bufferAttributeConstr( typedArray, attribute.itemSize, attribute.normalized );

                        }

                        if ( attribute.name !== undefined ) bufferAttribute.name = attribute.name;
                        geometry.setAttribute( key, bufferAttribute );

                }

                const morphAttributes = json.data.morphAttributes;

                if ( morphAttributes ) {

                        for ( const key in morphAttributes ) {

                                const attributeArray = morphAttributes[ key ];

                                const array = [];

                                for ( let i = 0, il = attributeArray.length; i < il; i ++ ) {

                                        const attribute = attributeArray[ i ];
                                        let bufferAttribute;

                                        if ( attribute.isInterleavedBufferAttribute ) {

                                                const interleavedBuffer = getInterleavedBuffer( json.data, attribute.data );
                                                bufferAttribute = new InterleavedBufferAttribute( interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized );

                                        } else {

                                                const typedArray = getTypedArray( attribute.type, attribute.array );
                                                bufferAttribute = new BufferAttribute( typedArray, attribute.itemSize, attribute.normalized );

                                        }

                                        if ( attribute.name !== undefined ) bufferAttribute.name = attribute.name;
                                        array.push( bufferAttribute );

                                }

                                geometry.morphAttributes[ key ] = array;

                        }

                }

                const morphTargetsRelative = json.data.morphTargetsRelative;

                if ( morphTargetsRelative ) {

                        geometry.morphTargetsRelative = true;

                }

                const groups = json.data.groups || json.data.drawcalls || json.data.offsets;

                if ( groups !== undefined ) {

                        for ( let i = 0, n = groups.length; i !== n; ++ i ) {

                                const group = groups[ i ];

                                geometry.addGroup( group.start, group.count, group.materialIndex );

                        }

                }

                const boundingSphere = json.data.boundingSphere;

                if ( boundingSphere !== undefined ) {

                        const center = new Vector3();

                        if ( boundingSphere.center !== undefined ) {

                                center.fromArray( boundingSphere.center );

                        }

                        geometry.boundingSphere = new Sphere( center, boundingSphere.radius );

                }

                if ( json.name ) geometry.name = json.name;
                if ( json.userData ) geometry.userData = json.userData;

                return geometry;

        }

    } );

    function ImageBitmapLoader( manager ) {

        if ( typeof createImageBitmap === 'undefined' ) {

                console.warn( 'THREE.ImageBitmapLoader: createImageBitmap() not supported.' );

        }

        if ( typeof fetch === 'undefined' ) {

                console.warn( 'THREE.ImageBitmapLoader: fetch() not supported.' );

        }

        Loader.call( this, manager );

        this.options = { premultiplyAlpha: 'none' };

    }

    ImageBitmapLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: ImageBitmapLoader,

        isImageBitmapLoader: true,

        setOptions: function setOptions( options ) {

                this.options = options;

                return this;

        },

        load: function ( url, onLoad, onProgress, onError ) {

                if ( url === undefined ) url = '';

                if ( this.path !== undefined ) url = this.path + url;

                url = this.manager.resolveURL( url );

                const scope = this;

                const cached = Cache.get( url );

                if ( cached !== undefined ) {

                        scope.manager.itemStart( url );

                        setTimeout( function () {

                                if ( onLoad ) onLoad( cached );

                                scope.manager.itemEnd( url );

                        }, 0 );

                        return cached;

                }

                const fetchOptions = {};
                fetchOptions.credentials = ( this.crossOrigin === 'anonymous' ) ? 'same-origin' : 'include';

                fetch( url, fetchOptions ).then( function ( res ) {

                        return res.blob();

                } ).then( function ( blob ) {

                        return createImageBitmap( blob, scope.options );

                } ).then( function ( imageBitmap ) {

                        Cache.add( url, imageBitmap );

                        if ( onLoad ) onLoad( imageBitmap );

                        scope.manager.itemEnd( url );

                } ).catch( function ( e ) {

                        if ( onError ) onError( e );

                        scope.manager.itemError( url );
                        scope.manager.itemEnd( url );

                } );

                scope.manager.itemStart( url );

        }

    } );

    function ShapePath() {

        this.type = 'ShapePath';

        this.color = new Color();

        this.subPaths = [];
        this.currentPath = null;

    }

    Object.assign( ShapePath.prototype, {

        moveTo: function ( x, y ) {

                this.currentPath = new Path();
                this.subPaths.push( this.currentPath );
                this.currentPath.moveTo( x, y );

                return this;

        },

        lineTo: function ( x, y ) {

                this.currentPath.lineTo( x, y );

                return this;

        },

        quadraticCurveTo: function ( aCPx, aCPy, aX, aY ) {

                this.currentPath.quadraticCurveTo( aCPx, aCPy, aX, aY );

                return this;

        },

        bezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {

                this.currentPath.bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY );

                return this;

        },

        splineThru: function ( pts ) {

                this.currentPath.splineThru( pts );

                return this;

        },

        toShapes: function ( isCCW, noHoles ) {

                function toShapesNoHoles( inSubpaths ) {

                        const shapes = [];

                        for ( let i = 0, l = inSubpaths.length; i < l; i ++ ) {

                                const tmpPath = inSubpaths[ i ];

                                const tmpShape = new Shape();
                                tmpShape.curves = tmpPath.curves;

                                shapes.push( tmpShape );

                        }

                        return shapes;

                }

                function isPointInsidePolygon( inPt, inPolygon ) {

                        const polyLen = inPolygon.length;

                        // inPt on polygon contour => immediate success    or
                        // toggling of inside/outside at every single! intersection point of an edge
                        //  with the horizontal line through inPt, left of inPt
                        //  not counting lowerY endpoints of edges and whole edges on that line
                        let inside = false;
                        for ( let p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {

                                let edgeLowPt = inPolygon[ p ];
                                let edgeHighPt = inPolygon[ q ];

                                let edgeDx = edgeHighPt.x - edgeLowPt.x;
                                let edgeDy = edgeHighPt.y - edgeLowPt.y;

                                if ( Math.abs( edgeDy ) > Number.EPSILON ) {

                                        // not parallel
                                        if ( edgeDy < 0 ) {

                                                edgeLowPt = inPolygon[ q ]; edgeDx = - edgeDx;
                                                edgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;

                                        }

                                        if ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) )            continue;

                                        if ( inPt.y === edgeLowPt.y ) {

                                                if ( inPt.x === edgeLowPt.x )           return  true;           // inPt is on contour ?
                                                // continue;                            // no intersection or edgeLowPt => doesn't count !!!

                                        } else {

                                                const perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );
                                                if ( perpEdge === 0 )                           return  true;           // inPt is on contour ?
                                                if ( perpEdge < 0 )                             continue;
                                                inside = ! inside;              // true intersection left of inPt

                                        }

                                } else {

                                        // parallel or collinear
                                        if ( inPt.y !== edgeLowPt.y )           continue;                       // parallel
                                        // edge lies on the same horizontal line as inPt
                                        if ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||
                                                 ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )          return  true;   // inPt: Point on contour !
                                        // continue;

                                }

                        }

                        return  inside;

                }

                const isClockWise = ShapeUtils.isClockWise;

                const subPaths = this.subPaths;
                if ( subPaths.length === 0 ) return [];

                if ( noHoles === true ) return  toShapesNoHoles( subPaths );


                let solid, tmpPath, tmpShape;
                const shapes = [];

                if ( subPaths.length === 1 ) {

                        tmpPath = subPaths[ 0 ];
                        tmpShape = new Shape();
                        tmpShape.curves = tmpPath.curves;
                        shapes.push( tmpShape );
                        return shapes;

                }

                let holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );
                holesFirst = isCCW ? ! holesFirst : holesFirst;

                // console.log("Holes first", holesFirst);

                const betterShapeHoles = [];
                const newShapes = [];
                let newShapeHoles = [];
                let mainIdx = 0;
                let tmpPoints;

                newShapes[ mainIdx ] = undefined;
                newShapeHoles[ mainIdx ] = [];

                for ( let i = 0, l = subPaths.length; i < l; i ++ ) {

                        tmpPath = subPaths[ i ];
                        tmpPoints = tmpPath.getPoints();
                        solid = isClockWise( tmpPoints );
                        solid = isCCW ? ! solid : solid;

                        if ( solid ) {

                                if ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )     mainIdx ++;

                                newShapes[ mainIdx ] = { s: new Shape(), p: tmpPoints };
                                newShapes[ mainIdx ].s.curves = tmpPath.curves;

                                if ( holesFirst )       mainIdx ++;
                                newShapeHoles[ mainIdx ] = [];

                                //console.log('cw', i);

                        } else {

                                newShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );

                                //console.log('ccw', i);

                        }

                }

                // only Holes? -> probably all Shapes with wrong orientation
                if ( ! newShapes[ 0 ] ) return  toShapesNoHoles( subPaths );


                if ( newShapes.length > 1 ) {

                        let ambiguous = false;
                        const toChange = [];

                        for ( let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {

                                betterShapeHoles[ sIdx ] = [];

                        }

                        for ( let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {

                                const sho = newShapeHoles[ sIdx ];

                                for ( let hIdx = 0; hIdx < sho.length; hIdx ++ ) {

                                        const ho = sho[ hIdx ];
                                        let hole_unassigned = true;

                                        for ( let s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {

                                                if ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {

                                                        if ( sIdx !== s2Idx )   toChange.push( { froms: sIdx, tos: s2Idx, hole: hIdx } );
                                                        if ( hole_unassigned ) {

                                                                hole_unassigned = false;
                                                                betterShapeHoles[ s2Idx ].push( ho );

                                                        } else {

                                                                ambiguous = true;

                                                        }

                                                }

                                        }

                                        if ( hole_unassigned ) {

                                                betterShapeHoles[ sIdx ].push( ho );

                                        }

                                }

                        }
                        // console.log("ambiguous: ", ambiguous);

                        if ( toChange.length > 0 ) {

                                // console.log("to change: ", toChange);
                                if ( ! ambiguous )      newShapeHoles = betterShapeHoles;

                        }

                }

                let tmpHoles;

                for ( let i = 0, il = newShapes.length; i < il; i ++ ) {

                        tmpShape = newShapes[ i ].s;
                        shapes.push( tmpShape );
                        tmpHoles = newShapeHoles[ i ];

                        for ( let j = 0, jl = tmpHoles.length; j < jl; j ++ ) {

                                tmpShape.holes.push( tmpHoles[ j ].h );

                        }

                }

                //console.log("shape", shapes);

                return shapes;

        }

    } );

    class Font {

        constructor( data ) {

                Object.defineProperty( this, 'isFont', { value: true } );

                this.type = 'Font';

                this.data = data;

        }

        generateShapes( text, size = 100 ) {

                const shapes = [];
                const paths = createPaths( text, size, this.data );

                for ( let p = 0, pl = paths.length; p < pl; p ++ ) {

                        Array.prototype.push.apply( shapes, paths[ p ].toShapes() );

                }

                return shapes;

        }

    }

    function createPaths( text, size, data ) {

        const chars = Array.from ? Array.from( text ) : String( text ).split( '' ); // workaround for IE11, see #13988
        const scale = size / data.resolution;
        const line_height = ( data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness ) * scale;

        const paths = [];

        let offsetX = 0, offsetY = 0;

        for ( let i = 0; i < chars.length; i ++ ) {

                const char = chars[ i ];

                if ( char === '\n' ) {

                        offsetX = 0;
                        offsetY -= line_height;

                } else {

                        const ret = createPath( char, scale, offsetX, offsetY, data );
                        offsetX += ret.offsetX;
                        paths.push( ret.path );

                }

        }

        return paths;

    }

    function createPath( char, scale, offsetX, offsetY, data ) {

        const glyph = data.glyphs[ char ] || data.glyphs[ '?' ];

        if ( ! glyph ) {

                console.error( 'THREE.Font: character "' + char + '" does not exists in font family ' + data.familyName + '.' );

                return;

        }

        const path = new ShapePath();

        let x, y, cpx, cpy, cpx1, cpy1, cpx2, cpy2;

        if ( glyph.o ) {

                const outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) );

                for ( let i = 0, l = outline.length; i < l; ) {

                        const action = outline[ i ++ ];

                        switch ( action ) {

                                case 'm': // moveTo

                                        x = outline[ i ++ ] * scale + offsetX;
                                        y = outline[ i ++ ] * scale + offsetY;

                                        path.moveTo( x, y );

                                        break;

                                case 'l': // lineTo

                                        x = outline[ i ++ ] * scale + offsetX;
                                        y = outline[ i ++ ] * scale + offsetY;

                                        path.lineTo( x, y );

                                        break;

                                case 'q': // quadraticCurveTo

                                        cpx = outline[ i ++ ] * scale + offsetX;
                                        cpy = outline[ i ++ ] * scale + offsetY;
                                        cpx1 = outline[ i ++ ] * scale + offsetX;
                                        cpy1 = outline[ i ++ ] * scale + offsetY;

                                        path.quadraticCurveTo( cpx1, cpy1, cpx, cpy );

                                        break;

                                case 'b': // bezierCurveTo

                                        cpx = outline[ i ++ ] * scale + offsetX;
                                        cpy = outline[ i ++ ] * scale + offsetY;
                                        cpx1 = outline[ i ++ ] * scale + offsetX;
                                        cpy1 = outline[ i ++ ] * scale + offsetY;
                                        cpx2 = outline[ i ++ ] * scale + offsetX;
                                        cpy2 = outline[ i ++ ] * scale + offsetY;

                                        path.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );

                                        break;

                        }

                }

        }

        return { offsetX: glyph.ha * scale, path: path };

    }

    function FontLoader( manager ) {

        Loader.call( this, manager );

    }

    FontLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: FontLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const loader = new FileLoader( this.manager );
                loader.setPath( this.path );
                loader.setRequestHeader( this.requestHeader );
                loader.setWithCredentials( scope.withCredentials );
                loader.load( url, function ( text ) {

                        let json;

                        try {

                                json = JSON.parse( text );

                        } catch ( e ) {

                                console.warn( 'THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead.' );
                                json = JSON.parse( text.substring( 65, text.length - 2 ) );

                        }

                        const font = scope.parse( json );

                        if ( onLoad ) onLoad( font );

                }, onProgress, onError );

        },

        parse: function ( json ) {

                return new Font( json );

        }

    } );

    let _context;

    const AudioContext = {

        getContext: function () {

                if ( _context === undefined ) {

                        _context = new ( window.AudioContext || window.webkitAudioContext )();

                }

                return _context;

        },

        setContext: function ( value ) {

                _context = value;

        }

    };

    function AudioLoader( manager ) {

        Loader.call( this, manager );

    }

    AudioLoader.prototype = Object.assign( Object.create( Loader.prototype ), {

        constructor: AudioLoader,

        load: function ( url, onLoad, onProgress, onError ) {

                const scope = this;

                const loader = new FileLoader( scope.manager );
                loader.setResponseType( 'arraybuffer' );
                loader.setPath( scope.path );
                loader.setRequestHeader( scope.requestHeader );
                loader.setWithCredentials( scope.withCredentials );
                loader.load( url, function ( buffer ) {

                        try {

                                // Create a copy of the buffer. The `decodeAudioData` method
                                // detaches the buffer when complete, preventing reuse.
                                const bufferCopy = buffer.slice( 0 );

                                const context = AudioContext.getContext();
                                context.decodeAudioData( bufferCopy, function ( audioBuffer ) {

                                        onLoad( audioBuffer );

                                } );

                        } catch ( e ) {

                                if ( onError ) {

                                        onError( e );

                                } else {

                                        console.error( e );

                                }

                                scope.manager.itemError( url );

                        }

                }, onProgress, onError );

        }

    } );

    function HemisphereLightProbe( skyColor, groundColor, intensity ) {

        LightProbe.call( this, undefined, intensity );

        const color1 = new Color().set( skyColor );
        const color2 = new Color().set( groundColor );

        const sky = new Vector3( color1.r, color1.g, color1.b );
        const ground = new Vector3( color2.r, color2.g, color2.b );

        // without extra factor of PI in the shader, should = 1 / Math.sqrt( Math.PI );
        const c0 = Math.sqrt( Math.PI );
        const c1 = c0 * Math.sqrt( 0.75 );

        this.sh.coefficients[ 0 ].copy( sky ).add( ground ).multiplyScalar( c0 );
        this.sh.coefficients[ 1 ].copy( sky ).sub( ground ).multiplyScalar( c1 );

    }

    HemisphereLightProbe.prototype = Object.assign( Object.create( LightProbe.prototype ), {

        constructor: HemisphereLightProbe,

        isHemisphereLightProbe: true,

        copy: function ( source ) { // modifying colors not currently supported

                LightProbe.prototype.copy.call( this, source );

                return this;

        },

        toJSON: function ( meta ) {

                const data = LightProbe.prototype.toJSON.call( this, meta );

                // data.sh = this.sh.toArray(); // todo

                return data;

        }

    } );

    function AmbientLightProbe( color, intensity ) {

        LightProbe.call( this, undefined, intensity );

        const color1 = new Color().set( color );

        // without extra factor of PI in the shader, would be 2 / Math.sqrt( Math.PI );
        this.sh.coefficients[ 0 ].set( color1.r, color1.g, color1.b ).multiplyScalar( 2 * Math.sqrt( Math.PI ) );

    }

    AmbientLightProbe.prototype = Object.assign( Object.create( LightProbe.prototype ), {

        constructor: AmbientLightProbe,

        isAmbientLightProbe: true,

        copy: function ( source ) { // modifying color not currently supported

                LightProbe.prototype.copy.call( this, source );

                return this;

        },

        toJSON: function ( meta ) {

                const data = LightProbe.prototype.toJSON.call( this, meta );

                // data.sh = this.sh.toArray(); // todo

                return data;

        }

    } );

    const _eyeRight = new Matrix4();
    const _eyeLeft = new Matrix4();

    function StereoCamera() {

        this.type = 'StereoCamera';

        this.aspect = 1;

        this.eyeSep = 0.064;

        this.cameraL = new PerspectiveCamera();
        this.cameraL.layers.enable( 1 );
        this.cameraL.matrixAutoUpdate = false;

        this.cameraR = new PerspectiveCamera();
        this.cameraR.layers.enable( 2 );
        this.cameraR.matrixAutoUpdate = false;

        this._cache = {
                focus: null,
                fov: null,
                aspect: null,
                near: null,
                far: null,
                zoom: null,
                eyeSep: null
        };

    }

    Object.assign( StereoCamera.prototype, {

        update: function ( camera ) {

                const cache = this._cache;

                const needsUpdate = cache.focus !== camera.focus || cache.fov !== camera.fov ||
                        cache.aspect !== camera.aspect * this.aspect || cache.near !== camera.near ||
                        cache.far !== camera.far || cache.zoom !== camera.zoom || cache.eyeSep !== this.eyeSep;

                if ( needsUpdate ) {

                        cache.focus = camera.focus;
                        cache.fov = camera.fov;
                        cache.aspect = camera.aspect * this.aspect;
                        cache.near = camera.near;
                        cache.far = camera.far;
                        cache.zoom = camera.zoom;
                        cache.eyeSep = this.eyeSep;

                        // Off-axis stereoscopic effect based on
                        // http://paulbourke.net/stereographics/stereorender/

                        const projectionMatrix = camera.projectionMatrix.clone();
                        const eyeSepHalf = cache.eyeSep / 2;
                        const eyeSepOnProjection = eyeSepHalf * cache.near / cache.focus;
                        const ymax = ( cache.near * Math.tan( MathUtils.DEG2RAD * cache.fov * 0.5 ) ) / cache.zoom;
                        let xmin, xmax;

                        // translate xOffset

                        _eyeLeft.elements[ 12 ] = - eyeSepHalf;
                        _eyeRight.elements[ 12 ] = eyeSepHalf;

                        // for left eye

                        xmin = - ymax * cache.aspect + eyeSepOnProjection;
                        xmax = ymax * cache.aspect + eyeSepOnProjection;

                        projectionMatrix.elements[ 0 ] = 2 * cache.near / ( xmax - xmin );
                        projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );

                        this.cameraL.projectionMatrix.copy( projectionMatrix );

                        // for right eye

                        xmin = - ymax * cache.aspect - eyeSepOnProjection;
                        xmax = ymax * cache.aspect - eyeSepOnProjection;

                        projectionMatrix.elements[ 0 ] = 2 * cache.near / ( xmax - xmin );
                        projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );

                        this.cameraR.projectionMatrix.copy( projectionMatrix );

                }

                this.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( _eyeLeft );
                this.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( _eyeRight );

        }

    } );

    class Audio extends Object3D {

        constructor( listener ) {

                super();

                this.type = 'Audio';

                this.listener = listener;
                this.context = listener.context;

                this.gain = this.context.createGain();
                this.gain.connect( listener.getInput() );

                this.autoplay = false;

                this.buffer = null;
                this.detune = 0;
                this.loop = false;
                this.loopStart = 0;
                this.loopEnd = 0;
                this.offset = 0;
                this.duration = undefined;
                this.playbackRate = 1;
                this.isPlaying = false;
                this.hasPlaybackControl = true;
                this.source = null;
                this.sourceType = 'empty';

                this._startedAt = 0;
                this._progress = 0;
                this._connected = false;

                this.filters = [];

        }

        getOutput() {

                return this.gain;

        }

        setNodeSource( audioNode ) {

                this.hasPlaybackControl = false;
                this.sourceType = 'audioNode';
                this.source = audioNode;
                this.connect();

                return this;

        }

        setMediaElementSource( mediaElement ) {

                this.hasPlaybackControl = false;
                this.sourceType = 'mediaNode';
                this.source = this.context.createMediaElementSource( mediaElement );
                this.connect();

                return this;

        }

        setMediaStreamSource( mediaStream ) {

                this.hasPlaybackControl = false;
                this.sourceType = 'mediaStreamNode';
                this.source = this.context.createMediaStreamSource( mediaStream );
                this.connect();

                return this;

        }

        setBuffer( audioBuffer ) {

                this.buffer = audioBuffer;
                this.sourceType = 'buffer';

                if ( this.autoplay ) this.play();

                return this;

        }

        play( delay = 0 ) {

                if ( this.isPlaying === true ) {

                        console.warn( 'THREE.Audio: Audio is already playing.' );
                        return;

                }

                if ( this.hasPlaybackControl === false ) {

                        console.warn( 'THREE.Audio: this Audio has no playback control.' );
                        return;

                }

                this._startedAt = this.context.currentTime + delay;

                const source = this.context.createBufferSource();
                source.buffer = this.buffer;
                source.loop = this.loop;
                source.loopStart = this.loopStart;
                source.loopEnd = this.loopEnd;
                source.onended = this.onEnded.bind( this );
                source.start( this._startedAt, this._progress + this.offset, this.duration );

                this.isPlaying = true;

                this.source = source;

                this.setDetune( this.detune );
                this.setPlaybackRate( this.playbackRate );

                return this.connect();

        }

        pause() {

                if ( this.hasPlaybackControl === false ) {

                        console.warn( 'THREE.Audio: this Audio has no playback control.' );
                        return;

                }

                if ( this.isPlaying === true ) {

                        // update current progress

                        this._progress += Math.max( this.context.currentTime - this._startedAt, 0 ) * this.playbackRate;

                        if ( this.loop === true ) {

                                // ensure _progress does not exceed duration with looped audios

                                this._progress = this._progress % ( this.duration || this.buffer.duration );

                        }

                        this.source.stop();
                        this.source.onended = null;

                        this.isPlaying = false;

                }

                return this;

        }

        stop() {

                if ( this.hasPlaybackControl === false ) {

                        console.warn( 'THREE.Audio: this Audio has no playback control.' );
                        return;

                }

                this._progress = 0;

                this.source.stop();
                this.source.onended = null;
                this.isPlaying = false;

                return this;

        }

        connect() {

                if ( this.filters.length > 0 ) {

                        this.source.connect( this.filters[ 0 ] );

                        for ( let i = 1, l = this.filters.length; i < l; i ++ ) {

                                this.filters[ i - 1 ].connect( this.filters[ i ] );

                        }

                        this.filters[ this.filters.length - 1 ].connect( this.getOutput() );

                } else {

                        this.source.connect( this.getOutput() );

                }

                this._connected = true;

                return this;

        }

        disconnect() {

                if ( this.filters.length > 0 ) {

                        this.source.disconnect( this.filters[ 0 ] );

                        for ( let i = 1, l = this.filters.length; i < l; i ++ ) {

                                this.filters[ i - 1 ].disconnect( this.filters[ i ] );

                        }

                        this.filters[ this.filters.length - 1 ].disconnect( this.getOutput() );

                } else {

                        this.source.disconnect( this.getOutput() );

                }

                this._connected = false;

                return this;

        }

        getFilters() {

                return this.filters;

        }

        setFilters( value ) {

                if ( ! value ) value = [];

                if ( this._connected === true ) {

                        this.disconnect();
                        this.filters = value.slice();
                        this.connect();

                } else {

                        this.filters = value.slice();

                }

                return this;

        }

        setDetune( value ) {

                this.detune = value;

                if ( this.source.detune === undefined ) return; // only set detune when available

                if ( this.isPlaying === true ) {

                        this.source.detune.setTargetAtTime( this.detune, this.context.currentTime, 0.01 );

                }

                return this;

        }

        getDetune() {

                return this.detune;

        }

        getFilter() {

                return this.getFilters()[ 0 ];

        }

        setFilter( filter ) {

                return this.setFilters( filter ? [ filter ] : [] );

        }

        setPlaybackRate( value ) {

                if ( this.hasPlaybackControl === false ) {

                        console.warn( 'THREE.Audio: this Audio has no playback control.' );
                        return;

                }

                this.playbackRate = value;

                if ( this.isPlaying === true ) {

                        this.source.playbackRate.setTargetAtTime( this.playbackRate, this.context.currentTime, 0.01 );

                }

                return this;

        }

        getPlaybackRate() {

                return this.playbackRate;

        }

        onEnded() {

                this.isPlaying = false;

        }

        getLoop() {

                if ( this.hasPlaybackControl === false ) {

                        console.warn( 'THREE.Audio: this Audio has no playback control.' );
                        return false;

                }

                return this.loop;

        }

        setLoop( value ) {

                if ( this.hasPlaybackControl === false ) {

                        console.warn( 'THREE.Audio: this Audio has no playback control.' );
                        return;

                }

                this.loop = value;

                if ( this.isPlaying === true ) {

                        this.source.loop = this.loop;

                }

                return this;

        }

        setLoopStart( value ) {

                this.loopStart = value;

                return this;

        }

        setLoopEnd( value ) {

                this.loopEnd = value;

                return this;

        }

        getVolume() {

                return this.gain.gain.value;

        }

        setVolume( value ) {

                this.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );

                return this;

        }

    }

    function PropertyMixer( binding, typeName, valueSize ) {

        this.binding = binding;
        this.valueSize = valueSize;

        let mixFunction,
                mixFunctionAdditive,
                setIdentity;

        // buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ]
        //
        // interpolators can use .buffer as their .result
        // the data then goes to 'incoming'
        //
        // 'accu0' and 'accu1' are used frame-interleaved for
        // the cumulative result and are compared to detect
        // changes
        //
        // 'orig' stores the original state of the property
        //
        // 'add' is used for additive cumulative results
        //
        // 'work' is optional and is only present for quaternion types. It is used
        // to store intermediate quaternion multiplication results

        switch ( typeName ) {

                case 'quaternion':
                        mixFunction = this._slerp;
                        mixFunctionAdditive = this._slerpAdditive;
                        setIdentity = this._setAdditiveIdentityQuaternion;

                        this.buffer = new Float64Array( valueSize * 6 );
                        this._workIndex = 5;
                        break;

                case 'string':
                case 'bool':
                        mixFunction = this._select;

                        // Use the regular mix function and for additive on these types,
                        // additive is not relevant for non-numeric types
                        mixFunctionAdditive = this._select;

                        setIdentity = this._setAdditiveIdentityOther;

                        this.buffer = new Array( valueSize * 5 );
                        break;

                default:
                        mixFunction = this._lerp;
                        mixFunctionAdditive = this._lerpAdditive;
                        setIdentity = this._setAdditiveIdentityNumeric;

                        this.buffer = new Float64Array( valueSize * 5 );

        }

        this._mixBufferRegion = mixFunction;
        this._mixBufferRegionAdditive = mixFunctionAdditive;
        this._setIdentity = setIdentity;
        this._origIndex = 3;
        this._addIndex = 4;

        this.cumulativeWeight = 0;
        this.cumulativeWeightAdditive = 0;

        this.useCount = 0;
        this.referenceCount = 0;

    }

    Object.assign( PropertyMixer.prototype, {

        // accumulate data in the 'incoming' region into 'accu<i>'
        accumulate: function ( accuIndex, weight ) {

                // note: happily accumulating nothing when weight = 0, the caller knows
                // the weight and shouldn't have made the call in the first place

                const buffer = this.buffer,
                        stride = this.valueSize,
                        offset = accuIndex * stride + stride;

                let currentWeight = this.cumulativeWeight;

                if ( currentWeight === 0 ) {

                        // accuN := incoming * weight

                        for ( let i = 0; i !== stride; ++ i ) {

                                buffer[ offset + i ] = buffer[ i ];

                        }

                        currentWeight = weight;

                } else {

                        // accuN := accuN + incoming * weight

                        currentWeight += weight;
                        const mix = weight / currentWeight;
                        this._mixBufferRegion( buffer, offset, 0, mix, stride );

                }

                this.cumulativeWeight = currentWeight;

        },

        // accumulate data in the 'incoming' region into 'add'
        accumulateAdditive: function ( weight ) {

                const buffer = this.buffer,
                        stride = this.valueSize,
                        offset = stride * this._addIndex;

                if ( this.cumulativeWeightAdditive === 0 ) {

                        // add = identity

                        this._setIdentity();

                }

                // add := add + incoming * weight

                this._mixBufferRegionAdditive( buffer, offset, 0, weight, stride );
                this.cumulativeWeightAdditive += weight;

        },

        // apply the state of 'accu<i>' to the binding when accus differ
        apply: function ( accuIndex ) {

                const stride = this.valueSize,
                        buffer = this.buffer,
                        offset = accuIndex * stride + stride,

                        weight = this.cumulativeWeight,
                        weightAdditive = this.cumulativeWeightAdditive,

                        binding = this.binding;

                this.cumulativeWeight = 0;
                this.cumulativeWeightAdditive = 0;

                if ( weight < 1 ) {

                        // accuN := accuN + original * ( 1 - cumulativeWeight )

                        const originalValueOffset = stride * this._origIndex;

                        this._mixBufferRegion(
                                buffer, offset, originalValueOffset, 1 - weight, stride );

                }

                if ( weightAdditive > 0 ) {

                        // accuN := accuN + additive accuN

                        this._mixBufferRegionAdditive( buffer, offset, this._addIndex * stride, 1, stride );

                }

                for ( let i = stride, e = stride + stride; i !== e; ++ i ) {

                        if ( buffer[ i ] !== buffer[ i + stride ] ) {

                                // value has changed -> update scene graph

                                binding.setValue( buffer, offset );
                                break;

                        }

                }

        },

        // remember the state of the bound property and copy it to both accus
        saveOriginalState: function () {

                const binding = this.binding;

                const buffer = this.buffer,
                        stride = this.valueSize,

                        originalValueOffset = stride * this._origIndex;

                binding.getValue( buffer, originalValueOffset );

                // accu[0..1] := orig -- initially detect changes against the original
                for ( let i = stride, e = originalValueOffset; i !== e; ++ i ) {

                        buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];

                }

                // Add to identity for additive
                this._setIdentity();

                this.cumulativeWeight = 0;
                this.cumulativeWeightAdditive = 0;

        },

        // apply the state previously taken via 'saveOriginalState' to the binding
        restoreOriginalState: function () {

                const originalValueOffset = this.valueSize * 3;
                this.binding.setValue( this.buffer, originalValueOffset );

        },

        _setAdditiveIdentityNumeric: function () {

                const startIndex = this._addIndex * this.valueSize;
                const endIndex = startIndex + this.valueSize;

                for ( let i = startIndex; i < endIndex; i ++ ) {

                        this.buffer[ i ] = 0;

                }

        },

        _setAdditiveIdentityQuaternion: function () {

                this._setAdditiveIdentityNumeric();
                this.buffer[ this._addIndex * this.valueSize + 3 ] = 1;

        },

        _setAdditiveIdentityOther: function () {

                const startIndex = this._origIndex * this.valueSize;
                const targetIndex = this._addIndex * this.valueSize;

                for ( let i = 0; i < this.valueSize; i ++ ) {

                        this.buffer[ targetIndex + i ] = this.buffer[ startIndex + i ];

                }

        },


        // mix functions

        _select: function ( buffer, dstOffset, srcOffset, t, stride ) {

                if ( t >= 0.5 ) {

                        for ( let i = 0; i !== stride; ++ i ) {

                                buffer[ dstOffset + i ] = buffer[ srcOffset + i ];

                        }

                }

        },

        _slerp: function ( buffer, dstOffset, srcOffset, t ) {

                Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t );

        },

        _slerpAdditive: function ( buffer, dstOffset, srcOffset, t, stride ) {

                const workOffset = this._workIndex * stride;

                // Store result in intermediate buffer offset
                Quaternion.multiplyQuaternionsFlat( buffer, workOffset, buffer, dstOffset, buffer, srcOffset );

                // Slerp to the intermediate result
                Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t );

        },

        _lerp: function ( buffer, dstOffset, srcOffset, t, stride ) {

                const s = 1 - t;

                for ( let i = 0; i !== stride; ++ i ) {

                        const j = dstOffset + i;

                        buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;

                }

        },

        _lerpAdditive: function ( buffer, dstOffset, srcOffset, t, stride ) {

                for ( let i = 0; i !== stride; ++ i ) {

                        const j = dstOffset + i;

                        buffer[ j ] = buffer[ j ] + buffer[ srcOffset + i ] * t;

                }

        }

    } );

    // Characters [].:/ are reserved for track binding syntax.
    const _RESERVED_CHARS_RE = '\\[\\]\\.:\\/';
    const _reservedRe = new RegExp( '[' + _RESERVED_CHARS_RE + ']', 'g' );

    // Attempts to allow node names from any language. ES5's `\w` regexp matches
    // only latin characters, and the unicode \p{L} is not yet supported. So
    // instead, we exclude reserved characters and match everything else.
    const _wordChar = '[^' + _RESERVED_CHARS_RE + ']';
    const _wordCharOrDot = '[^' + _RESERVED_CHARS_RE.replace( '\\.', '' ) + ']';

    // Parent directories, delimited by '/' or ':'. Currently unused, but must
    // be matched to parse the rest of the track name.
    const _directoryRe = /((?:WC+[\/:])*)/.source.replace( 'WC', _wordChar );

    // Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.
    const _nodeRe = /(WCOD+)?/.source.replace( 'WCOD', _wordCharOrDot );

    // Object on target node, and accessor. May not contain reserved
    // characters. Accessor may contain any character except closing bracket.
    const _objectRe = /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace( 'WC', _wordChar );

    // Property and accessor. May not contain reserved characters. Accessor may
    // contain any non-bracket characters.
    const _propertyRe = /\.(WC+)(?:\[(.+)\])?/.source.replace( 'WC', _wordChar );

    const _trackRe = new RegExp( ''
        + '^'
        + _directoryRe
        + _nodeRe
        + _objectRe
        + _propertyRe
        + '$'
    );

    const _supportedObjectNames = [ 'material', 'materials', 'bones' ];

    function Composite( targetGroup, path, optionalParsedPath ) {

        const parsedPath = optionalParsedPath || PropertyBinding.parseTrackName( path );

        this._targetGroup = targetGroup;
        this._bindings = targetGroup.subscribe_( path, parsedPath );

    }

    Object.assign( Composite.prototype, {

        getValue: function ( array, offset ) {

                this.bind(); // bind all binding

                const firstValidIndex = this._targetGroup.nCachedObjects_,
                        binding = this._bindings[ firstValidIndex ];

                // and only call .getValue on the first
                if ( binding !== undefined ) binding.getValue( array, offset );

        },

        setValue: function ( array, offset ) {

                const bindings = this._bindings;

                for ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {

                        bindings[ i ].setValue( array, offset );

                }

        },

        bind: function () {

                const bindings = this._bindings;

                for ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {

                        bindings[ i ].bind();

                }

        },

        unbind: function () {

                const bindings = this._bindings;

                for ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {

                        bindings[ i ].unbind();

                }

        }

    } );


    function PropertyBinding( rootNode, path, parsedPath ) {

        this.path = path;
        this.parsedPath = parsedPath || PropertyBinding.parseTrackName( path );

        this.node = PropertyBinding.findNode( rootNode, this.parsedPath.nodeName ) || rootNode;

        this.rootNode = rootNode;

    }

    Object.assign( PropertyBinding, {

        Composite: Composite,

        create: function ( root, path, parsedPath ) {

                if ( ! ( root && root.isAnimationObjectGroup ) ) {

                        return new PropertyBinding( root, path, parsedPath );

                } else {

                        return new PropertyBinding.Composite( root, path, parsedPath );

                }

        },

        /**
         * Replaces spaces with underscores and removes unsupported characters from
         * node names, to ensure compatibility with parseTrackName().
         *
         * @param {string} name Node name to be sanitized.
         * @return {string}
         */
        sanitizeNodeName: function ( name ) {

                return name.replace( /\s/g, '_' ).replace( _reservedRe, '' );

        },

        parseTrackName: function ( trackName ) {

                const matches = _trackRe.exec( trackName );

                if ( ! matches ) {

                        throw new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName );

                }

                const results = {
                        // directoryName: matches[ 1 ], // (tschw) currently unused
                        nodeName: matches[ 2 ],
                        objectName: matches[ 3 ],
                        objectIndex: matches[ 4 ],
                        propertyName: matches[ 5 ], // required
                        propertyIndex: matches[ 6 ]
                };

                const lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' );

                if ( lastDot !== undefined && lastDot !== - 1 ) {

                        const objectName = results.nodeName.substring( lastDot + 1 );

                        // Object names must be checked against an allowlist. Otherwise, there
                        // is no way to parse 'foo.bar.baz': 'baz' must be a property, but
                        // 'bar' could be the objectName, or part of a nodeName (which can
                        // include '.' characters).
                        if ( _supportedObjectNames.indexOf( objectName ) !== - 1 ) {

                                results.nodeName = results.nodeName.substring( 0, lastDot );
                                results.objectName = objectName;

                        }

                }

                if ( results.propertyName === null || results.propertyName.length === 0 ) {

                        throw new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName );

                }

                return results;

        },

        findNode: function ( root, nodeName ) {

                if ( ! nodeName || nodeName === '' || nodeName === '.' || nodeName === - 1 || nodeName === root.name || nodeName === root.uuid ) {

                        return root;

                }

                // search into skeleton bones.
                if ( root.skeleton ) {

                        const bone = root.skeleton.getBoneByName( nodeName );

                        if ( bone !== undefined ) {

                                return bone;

                        }

                }

                // search into node subtree.
                if ( root.children ) {

                        const searchNodeSubtree = function ( children ) {

                                for ( let i = 0; i < children.length; i ++ ) {

                                        const childNode = children[ i ];

                                        if ( childNode.name === nodeName || childNode.uuid === nodeName ) {

                                                return childNode;

                                        }

                                        const result = searchNodeSubtree( childNode.children );

                                        if ( result ) return result;

                                }

                                return null;

                        };

                        const subTreeNode = searchNodeSubtree( root.children );

                        if ( subTreeNode ) {

                                return subTreeNode;

                        }

                }

                return null;

        }

    } );

    Object.assign( PropertyBinding.prototype, { // prototype, continued

        // these are used to "bind" a nonexistent property
        _getValue_unavailable: function () {},
        _setValue_unavailable: function () {},

        BindingType: {
                Direct: 0,
                EntireArray: 1,
                ArrayElement: 2,
                HasFromToArray: 3
        },

        Versioning: {
                None: 0,
                NeedsUpdate: 1,
                MatrixWorldNeedsUpdate: 2
        },

        GetterByBindingType: [

                function getValue_direct( buffer, offset ) {

                        buffer[ offset ] = this.node[ this.propertyName ];

                },

                function getValue_array( buffer, offset ) {

                        const source = this.resolvedProperty;

                        for ( let i = 0, n = source.length; i !== n; ++ i ) {

                                buffer[ offset ++ ] = source[ i ];

                        }

                },

                function getValue_arrayElement( buffer, offset ) {

                        buffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];

                },

                function getValue_toArray( buffer, offset ) {

                        this.resolvedProperty.toArray( buffer, offset );

                }

        ],

        SetterByBindingTypeAndVersioning: [

                [
                        // Direct

                        function setValue_direct( buffer, offset ) {

                                this.targetObject[ this.propertyName ] = buffer[ offset ];

                        },

                        function setValue_direct_setNeedsUpdate( buffer, offset ) {

                                this.targetObject[ this.propertyName ] = buffer[ offset ];
                                this.targetObject.needsUpdate = true;

                        },

                        function setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {

                                this.targetObject[ this.propertyName ] = buffer[ offset ];
                                this.targetObject.matrixWorldNeedsUpdate = true;

                        }

                ], [

                        // EntireArray

                        function setValue_array( buffer, offset ) {

                                const dest = this.resolvedProperty;

                                for ( let i = 0, n = dest.length; i !== n; ++ i ) {

                                        dest[ i ] = buffer[ offset ++ ];

                                }

                        },

                        function setValue_array_setNeedsUpdate( buffer, offset ) {

                                const dest = this.resolvedProperty;

                                for ( let i = 0, n = dest.length; i !== n; ++ i ) {

                                        dest[ i ] = buffer[ offset ++ ];

                                }

                                this.targetObject.needsUpdate = true;

                        },

                        function setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {

                                const dest = this.resolvedProperty;

                                for ( let i = 0, n = dest.length; i !== n; ++ i ) {

                                        dest[ i ] = buffer[ offset ++ ];

                                }

                                this.targetObject.matrixWorldNeedsUpdate = true;

                        }

                ], [

                        // ArrayElement

                        function setValue_arrayElement( buffer, offset ) {

                                this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];

                        },

                        function setValue_arrayElement_setNeedsUpdate( buffer, offset ) {

                                this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
                                this.targetObject.needsUpdate = true;

                        },

                        function setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {

                                this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
                                this.targetObject.matrixWorldNeedsUpdate = true;

                        }

                ], [

                        // HasToFromArray

                        function setValue_fromArray( buffer, offset ) {

                                this.resolvedProperty.fromArray( buffer, offset );

                        },

                        function setValue_fromArray_setNeedsUpdate( buffer, offset ) {

                                this.resolvedProperty.fromArray( buffer, offset );
                                this.targetObject.needsUpdate = true;

                        },

                        function setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {

                                this.resolvedProperty.fromArray( buffer, offset );
                                this.targetObject.matrixWorldNeedsUpdate = true;

                        }

                ]

        ],

        getValue: function getValue_unbound( targetArray, offset ) {

                this.bind();
                this.getValue( targetArray, offset );

                // Note: This class uses a State pattern on a per-method basis:
                // 'bind' sets 'this.getValue' / 'setValue' and shadows the
                // prototype version of these methods with one that represents
                // the bound state. When the property is not found, the methods
                // become no-ops.

        },

        setValue: function getValue_unbound( sourceArray, offset ) {

                this.bind();
                this.setValue( sourceArray, offset );

        },

        // create getter / setter pair for a property in the scene graph
        bind: function () {

                let targetObject = this.node;
                const parsedPath = this.parsedPath;

                const objectName = parsedPath.objectName;
                const propertyName = parsedPath.propertyName;
                let propertyIndex = parsedPath.propertyIndex;

                if ( ! targetObject ) {

                        targetObject = PropertyBinding.findNode( this.rootNode, parsedPath.nodeName ) || this.rootNode;

                        this.node = targetObject;

                }

                // set fail state so we can just 'return' on error
                this.getValue = this._getValue_unavailable;
                this.setValue = this._setValue_unavailable;

                // ensure there is a value node
                if ( ! targetObject ) {

                        console.error( 'THREE.PropertyBinding: Trying to update node for track: ' + this.path + ' but it wasn\'t found.' );
                        return;

                }

                if ( objectName ) {

                        let objectIndex = parsedPath.objectIndex;

                        // special cases were we need to reach deeper into the hierarchy to get the face materials....
                        switch ( objectName ) {

                                case 'materials':

                                        if ( ! targetObject.material ) {

                                                console.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );
                                                return;

                                        }

                                        if ( ! targetObject.material.materials ) {

                                                console.error( 'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this );
                                                return;

                                        }

                                        targetObject = targetObject.material.materials;

                                        break;

                                case 'bones':

                                        if ( ! targetObject.skeleton ) {

                                                console.error( 'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this );
                                                return;

                                        }

                                        // potential future optimization: skip this if propertyIndex is already an integer
                                        // and convert the integer string to a true integer.

                                        targetObject = targetObject.skeleton.bones;

                                        // support resolving morphTarget names into indices.
                                        for ( let i = 0; i < targetObject.length; i ++ ) {

                                                if ( targetObject[ i ].name === objectIndex ) {

                                                        objectIndex = i;
                                                        break;

                                                }

                                        }

                                        break;

                                default:

                                        if ( targetObject[ objectName ] === undefined ) {

                                                console.error( 'THREE.PropertyBinding: Can not bind to objectName of node undefined.', this );
                                                return;

                                        }

                                        targetObject = targetObject[ objectName ];

                        }


                        if ( objectIndex !== undefined ) {

                                if ( targetObject[ objectIndex ] === undefined ) {

                                        console.error( 'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject );
                                        return;

                                }

                                targetObject = targetObject[ objectIndex ];

                        }

                }

                // resolve property
                const nodeProperty = targetObject[ propertyName ];

                if ( nodeProperty === undefined ) {

                        const nodeName = parsedPath.nodeName;

                        console.error( 'THREE.PropertyBinding: Trying to update property for track: ' + nodeName +
                                '.' + propertyName + ' but it wasn\'t found.', targetObject );
                        return;

                }

                // determine versioning scheme
                let versioning = this.Versioning.None;

                this.targetObject = targetObject;

                if ( targetObject.needsUpdate !== undefined ) { // material

                        versioning = this.Versioning.NeedsUpdate;

                } else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform

                        versioning = this.Versioning.MatrixWorldNeedsUpdate;

                }

                // determine how the property gets bound
                let bindingType = this.BindingType.Direct;

                if ( propertyIndex !== undefined ) {

                        // access a sub element of the property array (only primitives are supported right now)

                        if ( propertyName === 'morphTargetInfluences' ) {

                                // potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.

                                // support resolving morphTarget names into indices.
                                if ( ! targetObject.geometry ) {

                                        console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this );
                                        return;

                                }

                                if ( targetObject.geometry.isBufferGeometry ) {

                                        if ( ! targetObject.geometry.morphAttributes ) {

                                                console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this );
                                                return;

                                        }

                                        if ( targetObject.morphTargetDictionary[ propertyIndex ] !== undefined ) {

                                                propertyIndex = targetObject.morphTargetDictionary[ propertyIndex ];

                                        }


                                } else {

                                        console.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.', this );
                                        return;

                                }

                        }

                        bindingType = this.BindingType.ArrayElement;

                        this.resolvedProperty = nodeProperty;
                        this.propertyIndex = propertyIndex;

                } else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {

                        // must use copy for Object3D.Euler/Quaternion

                        bindingType = this.BindingType.HasFromToArray;

                        this.resolvedProperty = nodeProperty;

                } else if ( Array.isArray( nodeProperty ) ) {

                        bindingType = this.BindingType.EntireArray;

                        this.resolvedProperty = nodeProperty;

                } else {

                        this.propertyName = propertyName;

                }

                // select getter / setter
                this.getValue = this.GetterByBindingType[ bindingType ];
                this.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];

        },

        unbind: function () {

                this.node = null;

                // back to the prototype version of getValue / setValue
                // note: avoiding to mutate the shape of 'this' via 'delete'
                this.getValue = this._getValue_unbound;
                this.setValue = this._setValue_unbound;

        }

    } );

    // DECLARE ALIAS AFTER assign prototype
    Object.assign( PropertyBinding.prototype, {

        // initial state of these methods that calls 'bind'
        _getValue_unbound: PropertyBinding.prototype.getValue,
        _setValue_unbound: PropertyBinding.prototype.setValue,

    } );

    /**
     *
     * A group of objects that receives a shared animation state.
     *
     * Usage:
     *
     *  - Add objects you would otherwise pass as 'root' to the
     *    constructor or the .clipAction method of AnimationMixer.
     *
     *  - Instead pass this object as 'root'.
     *
     *  - You can also add and remove objects later when the mixer
     *    is running.
     *
     * Note:
     *
     *    Objects of this class appear as one object to the mixer,
     *    so cache control of the individual objects must be done
     *    on the group.
     *
     * Limitation:
     *
     *  - The animated properties must be compatible among the
     *    all objects in the group.
     *
     *  - A single property can either be controlled through a
     *    target group or directly, but not both.
     */

    function AnimationObjectGroup() {

        this.uuid = MathUtils.generateUUID();

        // cached objects followed by the active ones
        this._objects = Array.prototype.slice.call( arguments );

        this.nCachedObjects_ = 0; // threshold
        // note: read by PropertyBinding.Composite

        const indices = {};
        this._indicesByUUID = indices; // for bookkeeping

        for ( let i = 0, n = arguments.length; i !== n; ++ i ) {

                indices[ arguments[ i ].uuid ] = i;

        }

        this._paths = []; // inside: string
        this._parsedPaths = []; // inside: { we don't care, here }
        this._bindings = []; // inside: Array< PropertyBinding >
        this._bindingsIndicesByPath = {}; // inside: indices in these arrays

        const scope = this;

        this.stats = {

                objects: {
                        get total() {

                                return scope._objects.length;

                        },
                        get inUse() {

                                return this.total - scope.nCachedObjects_;

                        }
                },
                get bindingsPerObject() {

                        return scope._bindings.length;

                }

        };

    }

    Object.assign( AnimationObjectGroup.prototype, {

        isAnimationObjectGroup: true,

        add: function () {

                const objects = this._objects,
                        indicesByUUID = this._indicesByUUID,
                        paths = this._paths,
                        parsedPaths = this._parsedPaths,
                        bindings = this._bindings,
                        nBindings = bindings.length;

                let knownObject = undefined,
                        nObjects = objects.length,
                        nCachedObjects = this.nCachedObjects_;

                for ( let i = 0, n = arguments.length; i !== n; ++ i ) {

                        const object = arguments[ i ],
                                uuid = object.uuid;
                        let index = indicesByUUID[ uuid ];

                        if ( index === undefined ) {

                                // unknown object -> add it to the ACTIVE region

                                index = nObjects ++;
                                indicesByUUID[ uuid ] = index;
                                objects.push( object );

                                // accounting is done, now do the same for all bindings

                                for ( let j = 0, m = nBindings; j !== m; ++ j ) {

                                        bindings[ j ].push( new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ) );

                                }

                        } else if ( index < nCachedObjects ) {

                                knownObject = objects[ index ];

                                // move existing object to the ACTIVE region

                                const firstActiveIndex = -- nCachedObjects,
                                        lastCachedObject = objects[ firstActiveIndex ];

                                indicesByUUID[ lastCachedObject.uuid ] = index;
                                objects[ index ] = lastCachedObject;

                                indicesByUUID[ uuid ] = firstActiveIndex;
                                objects[ firstActiveIndex ] = object;

                                // accounting is done, now do the same for all bindings

                                for ( let j = 0, m = nBindings; j !== m; ++ j ) {

                                        const bindingsForPath = bindings[ j ],
                                                lastCached = bindingsForPath[ firstActiveIndex ];

                                        let binding = bindingsForPath[ index ];

                                        bindingsForPath[ index ] = lastCached;

                                        if ( binding === undefined ) {

                                                // since we do not bother to create new bindings
                                                // for objects that are cached, the binding may
                                                // or may not exist

                                                binding = new PropertyBinding( object, paths[ j ], parsedPaths[ j ] );

                                        }

                                        bindingsForPath[ firstActiveIndex ] = binding;

                                }

                        } else if ( objects[ index ] !== knownObject ) {

                                console.error( 'THREE.AnimationObjectGroup: Different objects with the same UUID ' +
                                        'detected. Clean the caches or recreate your infrastructure when reloading scenes.' );

                        } // else the object is already where we want it to be

                } // for arguments

                this.nCachedObjects_ = nCachedObjects;

        },

        remove: function () {

                const objects = this._objects,
                        indicesByUUID = this._indicesByUUID,
                        bindings = this._bindings,
                        nBindings = bindings.length;

                let nCachedObjects = this.nCachedObjects_;

                for ( let i = 0, n = arguments.length; i !== n; ++ i ) {

                        const object = arguments[ i ],
                                uuid = object.uuid,
                                index = indicesByUUID[ uuid ];

                        if ( index !== undefined && index >= nCachedObjects ) {

                                // move existing object into the CACHED region

                                const lastCachedIndex = nCachedObjects ++,
                                        firstActiveObject = objects[ lastCachedIndex ];

                                indicesByUUID[ firstActiveObject.uuid ] = index;
                                objects[ index ] = firstActiveObject;

                                indicesByUUID[ uuid ] = lastCachedIndex;
                                objects[ lastCachedIndex ] = object;

                                // accounting is done, now do the same for all bindings

                                for ( let j = 0, m = nBindings; j !== m; ++ j ) {

                                        const bindingsForPath = bindings[ j ],
                                                firstActive = bindingsForPath[ lastCachedIndex ],
                                                binding = bindingsForPath[ index ];

                                        bindingsForPath[ index ] = firstActive;
                                        bindingsForPath[ lastCachedIndex ] = binding;

                                }

                        }

                } // for arguments

                this.nCachedObjects_ = nCachedObjects;

        },

        // remove & forget
        uncache: function () {

                const objects = this._objects,
                        indicesByUUID = this._indicesByUUID,
                        bindings = this._bindings,
                        nBindings = bindings.length;

                let nCachedObjects = this.nCachedObjects_,
                        nObjects = objects.length;

                for ( let i = 0, n = arguments.length; i !== n; ++ i ) {

                        const object = arguments[ i ],
                                uuid = object.uuid,
                                index = indicesByUUID[ uuid ];

                        if ( index !== undefined ) {

                                delete indicesByUUID[ uuid ];

                                if ( index < nCachedObjects ) {

                                        // object is cached, shrink the CACHED region

                                        const firstActiveIndex = -- nCachedObjects,
                                                lastCachedObject = objects[ firstActiveIndex ],
                                                lastIndex = -- nObjects,
                                                lastObject = objects[ lastIndex ];

                                        // last cached object takes this object's place
                                        indicesByUUID[ lastCachedObject.uuid ] = index;
                                        objects[ index ] = lastCachedObject;

                                        // last object goes to the activated slot and pop
                                        indicesByUUID[ lastObject.uuid ] = firstActiveIndex;
                                        objects[ firstActiveIndex ] = lastObject;
                                        objects.pop();

                                        // accounting is done, now do the same for all bindings

                                        for ( let j = 0, m = nBindings; j !== m; ++ j ) {

                                                const bindingsForPath = bindings[ j ],
                                                        lastCached = bindingsForPath[ firstActiveIndex ],
                                                        last = bindingsForPath[ lastIndex ];

                                                bindingsForPath[ index ] = lastCached;
                                                bindingsForPath[ firstActiveIndex ] = last;
                                                bindingsForPath.pop();

                                        }

                                } else {

                                        // object is active, just swap with the last and pop

                                        const lastIndex = -- nObjects,
                                                lastObject = objects[ lastIndex ];

                                        if ( lastIndex > 0 ) {

                                                indicesByUUID[ lastObject.uuid ] = index;

                                        }

                                        objects[ index ] = lastObject;
                                        objects.pop();

                                        // accounting is done, now do the same for all bindings

                                        for ( let j = 0, m = nBindings; j !== m; ++ j ) {

                                                const bindingsForPath = bindings[ j ];

                                                bindingsForPath[ index ] = bindingsForPath[ lastIndex ];
                                                bindingsForPath.pop();

                                        }

                                } // cached or active

                        } // if object is known

                } // for arguments

                this.nCachedObjects_ = nCachedObjects;

        },

        // Internal interface used by befriended PropertyBinding.Composite:

        subscribe_: function ( path, parsedPath ) {

                // returns an array of bindings for the given path that is changed
                // according to the contained objects in the group

                const indicesByPath = this._bindingsIndicesByPath;
                let index = indicesByPath[ path ];
                const bindings = this._bindings;

                if ( index !== undefined ) return bindings[ index ];

                const paths = this._paths,
                        parsedPaths = this._parsedPaths,
                        objects = this._objects,
                        nObjects = objects.length,
                        nCachedObjects = this.nCachedObjects_,
                        bindingsForPath = new Array( nObjects );

                index = bindings.length;

                indicesByPath[ path ] = index;

                paths.push( path );
                parsedPaths.push( parsedPath );
                bindings.push( bindingsForPath );

                for ( let i = nCachedObjects, n = objects.length; i !== n; ++ i ) {

                        const object = objects[ i ];
                        bindingsForPath[ i ] = new PropertyBinding( object, path, parsedPath );

                }

                return bindingsForPath;

        },

        unsubscribe_: function ( path ) {

                // tells the group to forget about a property path and no longer
                // update the array previously obtained with 'subscribe_'

                const indicesByPath = this._bindingsIndicesByPath,
                        index = indicesByPath[ path ];

                if ( index !== undefined ) {

                        const paths = this._paths,
                                parsedPaths = this._parsedPaths,
                                bindings = this._bindings,
                                lastBindingsIndex = bindings.length - 1,
                                lastBindings = bindings[ lastBindingsIndex ],
                                lastBindingsPath = path[ lastBindingsIndex ];

                        indicesByPath[ lastBindingsPath ] = index;

                        bindings[ index ] = lastBindings;
                        bindings.pop();

                        parsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];
                        parsedPaths.pop();

                        paths[ index ] = paths[ lastBindingsIndex ];
                        paths.pop();

                }

        }

    } );

    class AnimationAction {

        constructor( mixer, clip, localRoot = null, blendMode = clip.blendMode ) {

                this._mixer = mixer;
                this._clip = clip;
                this._localRoot = localRoot;
                this.blendMode = blendMode;

                const tracks = clip.tracks,
                        nTracks = tracks.length,
                        interpolants = new Array( nTracks );

                const interpolantSettings = {
                        endingStart: ZeroCurvatureEnding,
                        endingEnd: ZeroCurvatureEnding
                };

                for ( let i = 0; i !== nTracks; ++ i ) {

                        const interpolant = tracks[ i ].createInterpolant( null );
                        interpolants[ i ] = interpolant;
                        interpolant.settings = interpolantSettings;

                }

                this._interpolantSettings = interpolantSettings;

                this._interpolants = interpolants; // bound by the mixer

                // inside: PropertyMixer (managed by the mixer)
                this._propertyBindings = new Array( nTracks );

                this._cacheIndex = null; // for the memory manager
                this._byClipCacheIndex = null; // for the memory manager

                this._timeScaleInterpolant = null;
                this._weightInterpolant = null;

                this.loop = LoopRepeat;
                this._loopCount = - 1;

                // global mixer time when the action is to be started
                // it's set back to 'null' upon start of the action
                this._startTime = null;

                // scaled local time of the action
                // gets clamped or wrapped to 0..clip.duration according to loop
                this.time = 0;

                this.timeScale = 1;
                this._effectiveTimeScale = 1;

                this.weight = 1;
                this._effectiveWeight = 1;

                this.repetitions = Infinity; // no. of repetitions when looping

                this.paused = false; // true -> zero effective time scale
                this.enabled = true; // false -> zero effective weight

                this.clampWhenFinished = false;// keep feeding the last frame?

                this.zeroSlopeAtStart = true;// for smooth interpolation w/o separate
                this.zeroSlopeAtEnd = true;// clips for start, loop and end

        }

        // State & Scheduling

        play() {

                this._mixer._activateAction( this );

                return this;

        }

        stop() {

                this._mixer._deactivateAction( this );

                return this.reset();

        }

        reset() {

                this.paused = false;
                this.enabled = true;

                this.time = 0; // restart clip
                this._loopCount = - 1;// forget previous loops
                this._startTime = null;// forget scheduling

                return this.stopFading().stopWarping();

        }

        isRunning() {

                return this.enabled && ! this.paused && this.timeScale !== 0 &&
                        this._startTime === null && this._mixer._isActiveAction( this );

        }

        // return true when play has been called
        isScheduled() {

                return this._mixer._isActiveAction( this );

        }

        startAt( time ) {

                this._startTime = time;

                return this;

        }

        setLoop( mode, repetitions ) {

                this.loop = mode;
                this.repetitions = repetitions;

                return this;

        }

        // Weight

        // set the weight stopping any scheduled fading
        // although .enabled = false yields an effective weight of zero, this
        // method does *not* change .enabled, because it would be confusing
        setEffectiveWeight( weight ) {

                this.weight = weight;

                // note: same logic as when updated at runtime
                this._effectiveWeight = this.enabled ? weight : 0;

                return this.stopFading();

        }

        // return the weight considering fading and .enabled
        getEffectiveWeight() {

                return this._effectiveWeight;

        }

        fadeIn( duration ) {

                return this._scheduleFading( duration, 0, 1 );

        }

        fadeOut( duration ) {

                return this._scheduleFading( duration, 1, 0 );

        }

        crossFadeFrom( fadeOutAction, duration, warp ) {

                fadeOutAction.fadeOut( duration );
                this.fadeIn( duration );

                if ( warp ) {

                        const fadeInDuration = this._clip.duration,
                                fadeOutDuration = fadeOutAction._clip.duration,

                                startEndRatio = fadeOutDuration / fadeInDuration,
                                endStartRatio = fadeInDuration / fadeOutDuration;

                        fadeOutAction.warp( 1.0, startEndRatio, duration );
                        this.warp( endStartRatio, 1.0, duration );

                }

                return this;

        }

        crossFadeTo( fadeInAction, duration, warp ) {

                return fadeInAction.crossFadeFrom( this, duration, warp );

        }

        stopFading() {

                const weightInterpolant = this._weightInterpolant;

                if ( weightInterpolant !== null ) {

                        this._weightInterpolant = null;
                        this._mixer._takeBackControlInterpolant( weightInterpolant );

                }

                return this;

        }

        // Time Scale Control

        // set the time scale stopping any scheduled warping
        // although .paused = true yields an effective time scale of zero, this
        // method does *not* change .paused, because it would be confusing
        setEffectiveTimeScale( timeScale ) {

                this.timeScale = timeScale;
                this._effectiveTimeScale = this.paused ? 0 : timeScale;

                return this.stopWarping();

        }

        // return the time scale considering warping and .paused
        getEffectiveTimeScale() {

                return this._effectiveTimeScale;

        }

        setDuration( duration ) {

                this.timeScale = this._clip.duration / duration;

                return this.stopWarping();

        }

        syncWith( action ) {

                this.time = action.time;
                this.timeScale = action.timeScale;

                return this.stopWarping();

        }

        halt( duration ) {

                return this.warp( this._effectiveTimeScale, 0, duration );

        }

        warp( startTimeScale, endTimeScale, duration ) {

                const mixer = this._mixer,
                        now = mixer.time,
                        timeScale = this.timeScale;

                let interpolant = this._timeScaleInterpolant;

                if ( interpolant === null ) {

                        interpolant = mixer._lendControlInterpolant();
                        this._timeScaleInterpolant = interpolant;

                }

                const times = interpolant.parameterPositions,
                        values = interpolant.sampleValues;

                times[ 0 ] = now;
                times[ 1 ] = now + duration;

                values[ 0 ] = startTimeScale / timeScale;
                values[ 1 ] = endTimeScale / timeScale;

                return this;

        }

        stopWarping() {

                const timeScaleInterpolant = this._timeScaleInterpolant;

                if ( timeScaleInterpolant !== null ) {

                        this._timeScaleInterpolant = null;
                        this._mixer._takeBackControlInterpolant( timeScaleInterpolant );

                }

                return this;

        }

        // Object Accessors

        getMixer() {

                return this._mixer;

        }

        getClip() {

                return this._clip;

        }

        getRoot() {

                return this._localRoot || this._mixer._root;

        }

        // Interna

        _update( time, deltaTime, timeDirection, accuIndex ) {

                // called by the mixer

                if ( ! this.enabled ) {

                        // call ._updateWeight() to update ._effectiveWeight

                        this._updateWeight( time );
                        return;

                }

                const startTime = this._startTime;

                if ( startTime !== null ) {

                        // check for scheduled start of action

                        const timeRunning = ( time - startTime ) * timeDirection;
                        if ( timeRunning < 0 || timeDirection === 0 ) {

                                return; // yet to come / don't decide when delta = 0

                        }

                        // start

                        this._startTime = null; // unschedule
                        deltaTime = timeDirection * timeRunning;

                }

                // apply time scale and advance time

                deltaTime *= this._updateTimeScale( time );
                const clipTime = this._updateTime( deltaTime );

                // note: _updateTime may disable the action resulting in
                // an effective weight of 0

                const weight = this._updateWeight( time );

                if ( weight > 0 ) {

                        const interpolants = this._interpolants;
                        const propertyMixers = this._propertyBindings;

                        switch ( this.blendMode ) {

                                case AdditiveAnimationBlendMode:

                                        for ( let j = 0, m = interpolants.length; j !== m; ++ j ) {

                                                interpolants[ j ].evaluate( clipTime );
                                                propertyMixers[ j ].accumulateAdditive( weight );

                                        }

                                        break;

                                case NormalAnimationBlendMode:
                                default:

                                        for ( let j = 0, m = interpolants.length; j !== m; ++ j ) {

                                                interpolants[ j ].evaluate( clipTime );
                                                propertyMixers[ j ].accumulate( accuIndex, weight );

                                        }

                        }

                }

        }

        _updateWeight( time ) {

                let weight = 0;

                if ( this.enabled ) {

                        weight = this.weight;
                        const interpolant = this._weightInterpolant;

                        if ( interpolant !== null ) {

                                const interpolantValue = interpolant.evaluate( time )[ 0 ];

                                weight *= interpolantValue;

                                if ( time > interpolant.parameterPositions[ 1 ] ) {

                                        this.stopFading();

                                        if ( interpolantValue === 0 ) {

                                                // faded out, disable
                                                this.enabled = false;

                                        }

                                }

                        }

                }

                this._effectiveWeight = weight;
                return weight;

        }

        _updateTimeScale( time ) {

                let timeScale = 0;

                if ( ! this.paused ) {

                        timeScale = this.timeScale;

                        const interpolant = this._timeScaleInterpolant;

                        if ( interpolant !== null ) {

                                const interpolantValue = interpolant.evaluate( time )[ 0 ];

                                timeScale *= interpolantValue;

                                if ( time > interpolant.parameterPositions[ 1 ] ) {

                                        this.stopWarping();

                                        if ( timeScale === 0 ) {

                                                // motion has halted, pause
                                                this.paused = true;

                                        } else {

                                                // warp done - apply final time scale
                                                this.timeScale = timeScale;

                                        }

                                }

                        }

                }

                this._effectiveTimeScale = timeScale;
                return timeScale;

        }

        _updateTime( deltaTime ) {

                const duration = this._clip.duration;
                const loop = this.loop;

                let time = this.time + deltaTime;
                let loopCount = this._loopCount;

                const pingPong = ( loop === LoopPingPong );

                if ( deltaTime === 0 ) {

                        if ( loopCount === - 1 ) return time;

                        return ( pingPong && ( loopCount & 1 ) === 1 ) ? duration - time : time;

                }

                if ( loop === LoopOnce ) {

                        if ( loopCount === - 1 ) {

                                // just started

                                this._loopCount = 0;
                                this._setEndings( true, true, false );

                        }

                        handle_stop: {

                                if ( time >= duration ) {

                                        time = duration;

                                } else if ( time < 0 ) {

                                        time = 0;

                                } else {

                                        this.time = time;

                                        break handle_stop;

                                }

                                if ( this.clampWhenFinished ) this.paused = true;
                                else this.enabled = false;

                                this.time = time;

                                this._mixer.dispatchEvent( {
                                        type: 'finished', action: this,
                                        direction: deltaTime < 0 ? - 1 : 1
                                } );

                        }

                } else { // repetitive Repeat or PingPong

                        if ( loopCount === - 1 ) {

                                // just started

                                if ( deltaTime >= 0 ) {

                                        loopCount = 0;

                                        this._setEndings( true, this.repetitions === 0, pingPong );

                                } else {

                                        // when looping in reverse direction, the initial
                                        // transition through zero counts as a repetition,
                                        // so leave loopCount at -1

                                        this._setEndings( this.repetitions === 0, true, pingPong );

                                }

                        }

                        if ( time >= duration || time < 0 ) {

                                // wrap around

                                const loopDelta = Math.floor( time / duration ); // signed
                                time -= duration * loopDelta;

                                loopCount += Math.abs( loopDelta );

                                const pending = this.repetitions - loopCount;

                                if ( pending <= 0 ) {

                                        // have to stop (switch state, clamp time, fire event)

                                        if ( this.clampWhenFinished ) this.paused = true;
                                        else this.enabled = false;

                                        time = deltaTime > 0 ? duration : 0;

                                        this.time = time;

                                        this._mixer.dispatchEvent( {
                                                type: 'finished', action: this,
                                                direction: deltaTime > 0 ? 1 : - 1
                                        } );

                                } else {

                                        // keep running

                                        if ( pending === 1 ) {

                                                // entering the last round

                                                const atStart = deltaTime < 0;
                                                this._setEndings( atStart, ! atStart, pingPong );

                                        } else {

                                                this._setEndings( false, false, pingPong );

                                        }

                                        this._loopCount = loopCount;

                                        this.time = time;

                                        this._mixer.dispatchEvent( {
                                                type: 'loop', action: this, loopDelta: loopDelta
                                        } );

                                }

                        } else {

                                this.time = time;

                        }

                        if ( pingPong && ( loopCount & 1 ) === 1 ) {

                                // invert time for the "pong round"

                                return duration - time;

                        }

                }

                return time;

        }

        _setEndings( atStart, atEnd, pingPong ) {

                const settings = this._interpolantSettings;

                if ( pingPong ) {

                        settings.endingStart = ZeroSlopeEnding;
                        settings.endingEnd = ZeroSlopeEnding;

                } else {

                        // assuming for LoopOnce atStart == atEnd == true

                        if ( atStart ) {

                                settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;

                        } else {

                                settings.endingStart = WrapAroundEnding;

                        }

                        if ( atEnd ) {

                                settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;

                        } else {

                                settings.endingEnd       = WrapAroundEnding;

                        }

                }

        }

        _scheduleFading( duration, weightNow, weightThen ) {

                const mixer = this._mixer, now = mixer.time;
                let interpolant = this._weightInterpolant;

                if ( interpolant === null ) {

                        interpolant = mixer._lendControlInterpolant();
                        this._weightInterpolant = interpolant;

                }

                const times = interpolant.parameterPositions,
                        values = interpolant.sampleValues;

                times[ 0 ] = now;
                values[ 0 ] = weightNow;
                times[ 1 ] = now + duration;
                values[ 1 ] = weightThen;

                return this;

        }

    }

    function AnimationMixer( root ) {

        this._root = root;
        this._initMemoryManager();
        this._accuIndex = 0;

        this.time = 0;

        this.timeScale = 1.0;

    }

    AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {

        constructor: AnimationMixer,

        _bindAction: function ( action, prototypeAction ) {

                const root = action._localRoot || this._root,
                        tracks = action._clip.tracks,
                        nTracks = tracks.length,
                        bindings = action._propertyBindings,
                        interpolants = action._interpolants,
                        rootUuid = root.uuid,
                        bindingsByRoot = this._bindingsByRootAndName;

                let bindingsByName = bindingsByRoot[ rootUuid ];

                if ( bindingsByName === undefined ) {

                        bindingsByName = {};
                        bindingsByRoot[ rootUuid ] = bindingsByName;

                }

                for ( let i = 0; i !== nTracks; ++ i ) {

                        const track = tracks[ i ],
                                trackName = track.name;

                        let binding = bindingsByName[ trackName ];

                        if ( binding !== undefined ) {

                                bindings[ i ] = binding;

                        } else {

                                binding = bindings[ i ];

                                if ( binding !== undefined ) {

                                        // existing binding, make sure the cache knows

                                        if ( binding._cacheIndex === null ) {

                                                ++ binding.referenceCount;
                                                this._addInactiveBinding( binding, rootUuid, trackName );

                                        }

                                        continue;

                                }

                                const path = prototypeAction && prototypeAction.
                                        _propertyBindings[ i ].binding.parsedPath;

                                binding = new PropertyMixer(
                                        PropertyBinding.create( root, trackName, path ),
                                        track.ValueTypeName, track.getValueSize() );

                                ++ binding.referenceCount;
                                this._addInactiveBinding( binding, rootUuid, trackName );

                                bindings[ i ] = binding;

                        }

                        interpolants[ i ].resultBuffer = binding.buffer;

                }

        },

        _activateAction: function ( action ) {

                if ( ! this._isActiveAction( action ) ) {

                        if ( action._cacheIndex === null ) {

                                // this action has been forgotten by the cache, but the user
                                // appears to be still using it -> rebind

                                const rootUuid = ( action._localRoot || this._root ).uuid,
                                        clipUuid = action._clip.uuid,
                                        actionsForClip = this._actionsByClip[ clipUuid ];

                                this._bindAction( action,
                                        actionsForClip && actionsForClip.knownActions[ 0 ] );

                                this._addInactiveAction( action, clipUuid, rootUuid );

                        }

                        const bindings = action._propertyBindings;

                        // increment reference counts / sort out state
                        for ( let i = 0, n = bindings.length; i !== n; ++ i ) {

                                const binding = bindings[ i ];

                                if ( binding.useCount ++ === 0 ) {

                                        this._lendBinding( binding );
                                        binding.saveOriginalState();

                                }

                        }

                        this._lendAction( action );

                }

        },

        _deactivateAction: function ( action ) {

                if ( this._isActiveAction( action ) ) {

                        const bindings = action._propertyBindings;

                        // decrement reference counts / sort out state
                        for ( let i = 0, n = bindings.length; i !== n; ++ i ) {

                                const binding = bindings[ i ];

                                if ( -- binding.useCount === 0 ) {

                                        binding.restoreOriginalState();
                                        this._takeBackBinding( binding );

                                }

                        }

                        this._takeBackAction( action );

                }

        },

        // Memory manager

        _initMemoryManager: function () {

                this._actions = []; // 'nActiveActions' followed by inactive ones
                this._nActiveActions = 0;

                this._actionsByClip = {};
                // inside:
                // {
                //      knownActions: Array< AnimationAction > - used as prototypes
                //      actionByRoot: AnimationAction - lookup
                // }


                this._bindings = []; // 'nActiveBindings' followed by inactive ones
                this._nActiveBindings = 0;

                this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >


                this._controlInterpolants = []; // same game as above
                this._nActiveControlInterpolants = 0;

                const scope = this;

                this.stats = {

                        actions: {
                                get total() {

                                        return scope._actions.length;

                                },
                                get inUse() {

                                        return scope._nActiveActions;

                                }
                        },
                        bindings: {
                                get total() {

                                        return scope._bindings.length;

                                },
                                get inUse() {

                                        return scope._nActiveBindings;

                                }
                        },
                        controlInterpolants: {
                                get total() {

                                        return scope._controlInterpolants.length;

                                },
                                get inUse() {

                                        return scope._nActiveControlInterpolants;

                                }
                        }

                };

        },

        // Memory management for AnimationAction objects

        _isActiveAction: function ( action ) {

                const index = action._cacheIndex;
                return index !== null && index < this._nActiveActions;

        },

        _addInactiveAction: function ( action, clipUuid, rootUuid ) {

                const actions = this._actions,
                        actionsByClip = this._actionsByClip;

                let actionsForClip = actionsByClip[ clipUuid ];

                if ( actionsForClip === undefined ) {

                        actionsForClip = {

                                knownActions: [ action ],
                                actionByRoot: {}

                        };

                        action._byClipCacheIndex = 0;

                        actionsByClip[ clipUuid ] = actionsForClip;

                } else {

                        const knownActions = actionsForClip.knownActions;

                        action._byClipCacheIndex = knownActions.length;
                        knownActions.push( action );

                }

                action._cacheIndex = actions.length;
                actions.push( action );

                actionsForClip.actionByRoot[ rootUuid ] = action;

        },

        _removeInactiveAction: function ( action ) {

                const actions = this._actions,
                        lastInactiveAction = actions[ actions.length - 1 ],
                        cacheIndex = action._cacheIndex;

                lastInactiveAction._cacheIndex = cacheIndex;
                actions[ cacheIndex ] = lastInactiveAction;
                actions.pop();

                action._cacheIndex = null;


                const clipUuid = action._clip.uuid,
                        actionsByClip = this._actionsByClip,
                        actionsForClip = actionsByClip[ clipUuid ],
                        knownActionsForClip = actionsForClip.knownActions,

                        lastKnownAction =
                                knownActionsForClip[ knownActionsForClip.length - 1 ],

                        byClipCacheIndex = action._byClipCacheIndex;

                lastKnownAction._byClipCacheIndex = byClipCacheIndex;
                knownActionsForClip[ byClipCacheIndex ] = lastKnownAction;
                knownActionsForClip.pop();

                action._byClipCacheIndex = null;


                const actionByRoot = actionsForClip.actionByRoot,
                        rootUuid = ( action._localRoot || this._root ).uuid;

                delete actionByRoot[ rootUuid ];

                if ( knownActionsForClip.length === 0 ) {

                        delete actionsByClip[ clipUuid ];

                }

                this._removeInactiveBindingsForAction( action );

        },

        _removeInactiveBindingsForAction: function ( action ) {

                const bindings = action._propertyBindings;

                for ( let i = 0, n = bindings.length; i !== n; ++ i ) {

                        const binding = bindings[ i ];

                        if ( -- binding.referenceCount === 0 ) {

                                this._removeInactiveBinding( binding );

                        }

                }

        },

        _lendAction: function ( action ) {

                // [ active actions |  inactive actions  ]
                // [  active actions >| inactive actions ]
                //                 s        a
                //                  <-swap->
                //                 a        s

                const actions = this._actions,
                        prevIndex = action._cacheIndex,

                        lastActiveIndex = this._nActiveActions ++,

                        firstInactiveAction = actions[ lastActiveIndex ];

                action._cacheIndex = lastActiveIndex;
                actions[ lastActiveIndex ] = action;

                firstInactiveAction._cacheIndex = prevIndex;
                actions[ prevIndex ] = firstInactiveAction;

        },

        _takeBackAction: function ( action ) {

                // [  active actions  | inactive actions ]
                // [ active actions |< inactive actions  ]
                //        a        s
                //         <-swap->
                //        s        a

                const actions = this._actions,
                        prevIndex = action._cacheIndex,

                        firstInactiveIndex = -- this._nActiveActions,

                        lastActiveAction = actions[ firstInactiveIndex ];

                action._cacheIndex = firstInactiveIndex;
                actions[ firstInactiveIndex ] = action;

                lastActiveAction._cacheIndex = prevIndex;
                actions[ prevIndex ] = lastActiveAction;

        },

        // Memory management for PropertyMixer objects

        _addInactiveBinding: function ( binding, rootUuid, trackName ) {

                const bindingsByRoot = this._bindingsByRootAndName,
                        bindings = this._bindings;

                let bindingByName = bindingsByRoot[ rootUuid ];

                if ( bindingByName === undefined ) {

                        bindingByName = {};
                        bindingsByRoot[ rootUuid ] = bindingByName;

                }

                bindingByName[ trackName ] = binding;

                binding._cacheIndex = bindings.length;
                bindings.push( binding );

        },

        _removeInactiveBinding: function ( binding ) {

                const bindings = this._bindings,
                        propBinding = binding.binding,
                        rootUuid = propBinding.rootNode.uuid,
                        trackName = propBinding.path,
                        bindingsByRoot = this._bindingsByRootAndName,
                        bindingByName = bindingsByRoot[ rootUuid ],

                        lastInactiveBinding = bindings[ bindings.length - 1 ],
                        cacheIndex = binding._cacheIndex;

                lastInactiveBinding._cacheIndex = cacheIndex;
                bindings[ cacheIndex ] = lastInactiveBinding;
                bindings.pop();

                delete bindingByName[ trackName ];

                if ( Object.keys( bindingByName ).length === 0 ) {

                        delete bindingsByRoot[ rootUuid ];

                }

        },

        _lendBinding: function ( binding ) {

                const bindings = this._bindings,
                        prevIndex = binding._cacheIndex,

                        lastActiveIndex = this._nActiveBindings ++,

                        firstInactiveBinding = bindings[ lastActiveIndex ];

                binding._cacheIndex = lastActiveIndex;
                bindings[ lastActiveIndex ] = binding;

                firstInactiveBinding._cacheIndex = prevIndex;
                bindings[ prevIndex ] = firstInactiveBinding;

        },

        _takeBackBinding: function ( binding ) {

                const bindings = this._bindings,
                        prevIndex = binding._cacheIndex,

                        firstInactiveIndex = -- this._nActiveBindings,

                        lastActiveBinding = bindings[ firstInactiveIndex ];

                binding._cacheIndex = firstInactiveIndex;
                bindings[ firstInactiveIndex ] = binding;

                lastActiveBinding._cacheIndex = prevIndex;
                bindings[ prevIndex ] = lastActiveBinding;

        },


        // Memory management of Interpolants for weight and time scale

        _lendControlInterpolant: function () {

                const interpolants = this._controlInterpolants,
                        lastActiveIndex = this._nActiveControlInterpolants ++;

                let interpolant = interpolants[ lastActiveIndex ];

                if ( interpolant === undefined ) {

                        interpolant = new LinearInterpolant(
                                new Float32Array( 2 ), new Float32Array( 2 ),
                                1, this._controlInterpolantsResultBuffer );

                        interpolant.__cacheIndex = lastActiveIndex;
                        interpolants[ lastActiveIndex ] = interpolant;

                }

                return interpolant;

        },

        _takeBackControlInterpolant: function ( interpolant ) {

                const interpolants = this._controlInterpolants,
                        prevIndex = interpolant.__cacheIndex,

                        firstInactiveIndex = -- this._nActiveControlInterpolants,

                        lastActiveInterpolant = interpolants[ firstInactiveIndex ];

                interpolant.__cacheIndex = firstInactiveIndex;
                interpolants[ firstInactiveIndex ] = interpolant;

                lastActiveInterpolant.__cacheIndex = prevIndex;
                interpolants[ prevIndex ] = lastActiveInterpolant;

        },

        _controlInterpolantsResultBuffer: new Float32Array( 1 ),

        // return an action for a clip optionally using a custom root target
        // object (this method allocates a lot of dynamic memory in case a
        // previously unknown clip/root combination is specified)
        clipAction: function ( clip, optionalRoot, blendMode ) {

                const root = optionalRoot || this._root,
                        rootUuid = root.uuid;

                let clipObject = typeof clip === 'string' ? AnimationClip.findByName( root, clip ) : clip;

                const clipUuid = clipObject !== null ? clipObject.uuid : clip;

                const actionsForClip = this._actionsByClip[ clipUuid ];
                let prototypeAction = null;

                if ( blendMode === undefined ) {

                        if ( clipObject !== null ) {

                                blendMode = clipObject.blendMode;

                        } else {

                                blendMode = NormalAnimationBlendMode;

                        }

                }

                if ( actionsForClip !== undefined ) {

                        const existingAction = actionsForClip.actionByRoot[ rootUuid ];

                        if ( existingAction !== undefined && existingAction.blendMode === blendMode ) {

                                return existingAction;

                        }

                        // we know the clip, so we don't have to parse all
                        // the bindings again but can just copy
                        prototypeAction = actionsForClip.knownActions[ 0 ];

                        // also, take the clip from the prototype action
                        if ( clipObject === null )
                                clipObject = prototypeAction._clip;

                }

                // clip must be known when specified via string
                if ( clipObject === null ) return null;

                // allocate all resources required to run it
                const newAction = new AnimationAction( this, clipObject, optionalRoot, blendMode );

                this._bindAction( newAction, prototypeAction );

                // and make the action known to the memory manager
                this._addInactiveAction( newAction, clipUuid, rootUuid );

                return newAction;

        },

        // get an existing action
        existingAction: function ( clip, optionalRoot ) {

                const root = optionalRoot || this._root,
                        rootUuid = root.uuid,

                        clipObject = typeof clip === 'string' ?
                                AnimationClip.findByName( root, clip ) : clip,

                        clipUuid = clipObject ? clipObject.uuid : clip,

                        actionsForClip = this._actionsByClip[ clipUuid ];

                if ( actionsForClip !== undefined ) {

                        return actionsForClip.actionByRoot[ rootUuid ] || null;

                }

                return null;

        },

        // deactivates all previously scheduled actions
        stopAllAction: function () {

                const actions = this._actions,
                        nActions = this._nActiveActions;

                for ( let i = nActions - 1; i >= 0; -- i ) {

                        actions[ i ].stop();

                }

                return this;

        },

        // advance the time and update apply the animation
        update: function ( deltaTime ) {

                deltaTime *= this.timeScale;

                const actions = this._actions,
                        nActions = this._nActiveActions,

                        time = this.time += deltaTime,
                        timeDirection = Math.sign( deltaTime ),

                        accuIndex = this._accuIndex ^= 1;

                // run active actions

                for ( let i = 0; i !== nActions; ++ i ) {

                        const action = actions[ i ];

                        action._update( time, deltaTime, timeDirection, accuIndex );

                }

                // update scene graph

                const bindings = this._bindings,
                        nBindings = this._nActiveBindings;

                for ( let i = 0; i !== nBindings; ++ i ) {

                        bindings[ i ].apply( accuIndex );

                }

                return this;

        },

        // Allows you to seek to a specific time in an animation.
        setTime: function ( timeInSeconds ) {

                this.time = 0; // Zero out time attribute for AnimationMixer object;
                for ( let i = 0; i < this._actions.length; i ++ ) {

                        this._actions[ i ].time = 0; // Zero out time attribute for all associated AnimationAction objects.

                }

                return this.update( timeInSeconds ); // Update used to set exact time. Returns "this" AnimationMixer object.

        },

        // return this mixer's root target object
        getRoot: function () {

                return this._root;

        },

        // free all resources specific to a particular clip
        uncacheClip: function ( clip ) {

                const actions = this._actions,
                        clipUuid = clip.uuid,
                        actionsByClip = this._actionsByClip,
                        actionsForClip = actionsByClip[ clipUuid ];

                if ( actionsForClip !== undefined ) {

                        // note: just calling _removeInactiveAction would mess up the
                        // iteration state and also require updating the state we can
                        // just throw away

                        const actionsToRemove = actionsForClip.knownActions;

                        for ( let i = 0, n = actionsToRemove.length; i !== n; ++ i ) {

                                const action = actionsToRemove[ i ];

                                this._deactivateAction( action );

                                const cacheIndex = action._cacheIndex,
                                        lastInactiveAction = actions[ actions.length - 1 ];

                                action._cacheIndex = null;
                                action._byClipCacheIndex = null;

                                lastInactiveAction._cacheIndex = cacheIndex;
                                actions[ cacheIndex ] = lastInactiveAction;
                                actions.pop();

                                this._removeInactiveBindingsForAction( action );

                        }

                        delete actionsByClip[ clipUuid ];

                }

        },

        // free all resources specific to a particular root target object
        uncacheRoot: function ( root ) {

                const rootUuid = root.uuid,
                        actionsByClip = this._actionsByClip;

                for ( const clipUuid in actionsByClip ) {

                        const actionByRoot = actionsByClip[ clipUuid ].actionByRoot,
                                action = actionByRoot[ rootUuid ];

                        if ( action !== undefined ) {

                                this._deactivateAction( action );
                                this._removeInactiveAction( action );

                        }

                }

                const bindingsByRoot = this._bindingsByRootAndName,
                        bindingByName = bindingsByRoot[ rootUuid ];

                if ( bindingByName !== undefined ) {

                        for ( const trackName in bindingByName ) {

                                const binding = bindingByName[ trackName ];
                                binding.restoreOriginalState();
                                this._removeInactiveBinding( binding );

                        }

                }

        },

        // remove a targeted clip from the cache
        uncacheAction: function ( clip, optionalRoot ) {

                const action = this.existingAction( clip, optionalRoot );

                if ( action !== null ) {

                        this._deactivateAction( action );
                        this._removeInactiveAction( action );

                }

        }

    } );

    class Uniform {

        constructor( value ) {

                if ( typeof value === 'string' ) {

                        console.warn( 'THREE.Uniform: Type parameter is no longer needed.' );
                        value = arguments[ 1 ];

                }

                this.value = value;

        }

        clone() {

                return new Uniform( this.value.clone === undefined ? this.value : this.value.clone() );

        }

    }

    function InstancedInterleavedBuffer( array, stride, meshPerAttribute ) {

        InterleavedBuffer.call( this, array, stride );

        this.meshPerAttribute = meshPerAttribute || 1;

    }

    InstancedInterleavedBuffer.prototype = Object.assign( Object.create( InterleavedBuffer.prototype ), {

        constructor: InstancedInterleavedBuffer,

        isInstancedInterleavedBuffer: true,

        copy: function ( source ) {

                InterleavedBuffer.prototype.copy.call( this, source );

                this.meshPerAttribute = source.meshPerAttribute;

                return this;

        },

        clone: function ( data ) {

                const ib = InterleavedBuffer.prototype.clone.call( this, data );

                ib.meshPerAttribute = this.meshPerAttribute;

                return ib;

        },

        toJSON: function ( data ) {

                const json = InterleavedBuffer.prototype.toJSON.call( this, data );

                json.isInstancedInterleavedBuffer = true;
                json.meshPerAttribute = this.meshPerAttribute;

                return json;

        }

    } );

    function GLBufferAttribute( buffer, type, itemSize, elementSize, count ) {

        this.buffer = buffer;
        this.type = type;
        this.itemSize = itemSize;
        this.elementSize = elementSize;
        this.count = count;

        this.version = 0;

    }

    Object.defineProperty( GLBufferAttribute.prototype, 'needsUpdate', {

        set: function ( value ) {

                if ( value === true ) this.version ++;

        }

    } );

    Object.assign( GLBufferAttribute.prototype, {

        isGLBufferAttribute: true,

        setBuffer: function ( buffer ) {

                this.buffer = buffer;

                return this;

        },

        setType: function ( type, elementSize ) {

                this.type = type;
                this.elementSize = elementSize;

                return this;

        },

        setItemSize: function ( itemSize ) {

                this.itemSize = itemSize;

                return this;

        },

        setCount: function ( count ) {

                this.count = count;

                return this;

        },

    } );

    function Raycaster( origin, direction, near, far ) {

        this.ray = new Ray( origin, direction );
        // direction is assumed to be normalized (for accurate distance calculations)

        this.near = near || 0;
        this.far = far || Infinity;
        this.camera = null;
        this.layers = new Layers();

        this.params = {
                Mesh: {},
                Line: { threshold: 1 },
                LOD: {},
                Points: { threshold: 1 },
                Sprite: {}
        };

        Object.defineProperties( this.params, {
                PointCloud: {
                        get: function () {

                                console.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' );
                                return this.Points;

                        }
                }
        } );

    }

    function ascSort( a, b ) {

        return a.distance - b.distance;

    }

    function intersectObject( object, raycaster, intersects, recursive ) {

        if ( object.layers.test( raycaster.layers ) ) {

                object.raycast( raycaster, intersects );

        }

        if ( recursive === true ) {

                const children = object.children;

                for ( let i = 0, l = children.length; i < l; i ++ ) {

                        intersectObject( children[ i ], raycaster, intersects, true );

                }

        }

    }

    Object.assign( Raycaster.prototype, {

        set: function ( origin, direction ) {

                // direction is assumed to be normalized (for accurate distance calculations)

                this.ray.set( origin, direction );

        },

        setFromCamera: function ( coords, camera ) {

                if ( camera && camera.isPerspectiveCamera ) {

                        this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
                        this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();
                        this.camera = camera;

                } else if ( camera && camera.isOrthographicCamera ) {

                        this.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera
                        this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );
                        this.camera = camera;

                } else {

                        console.error( 'THREE.Raycaster: Unsupported camera type: ' + camera.type );

                }

        },

        intersectObject: function ( object, recursive, optionalTarget ) {

                const intersects = optionalTarget || [];

                intersectObject( object, this, intersects, recursive );

                intersects.sort( ascSort );

                return intersects;

        },

        intersectObjects: function ( objects, recursive, optionalTarget ) {

                const intersects = optionalTarget || [];

                if ( Array.isArray( objects ) === false ) {

                        console.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' );
                        return intersects;

                }

                for ( let i = 0, l = objects.length; i < l; i ++ ) {

                        intersectObject( objects[ i ], this, intersects, recursive );

                }

                intersects.sort( ascSort );

                return intersects;

        }

    } );

    const _vector$8 = /*@__PURE__*/ new Vector2();

    class Box2 {

        constructor( min, max ) {

                Object.defineProperty( this, 'isBox2', { value: true } );

                this.min = ( min !== undefined ) ? min : new Vector2( + Infinity, + Infinity );
                this.max = ( max !== undefined ) ? max : new Vector2( - Infinity, - Infinity );

        }

        set( min, max ) {

                this.min.copy( min );
                this.max.copy( max );

                return this;

        }

        setFromPoints( points ) {

                this.makeEmpty();

                for ( let i = 0, il = points.length; i < il; i ++ ) {

                        this.expandByPoint( points[ i ] );

                }

                return this;

        }

        setFromCenterAndSize( center, size ) {

                const halfSize = _vector$8.copy( size ).multiplyScalar( 0.5 );
                this.min.copy( center ).sub( halfSize );
                this.max.copy( center ).add( halfSize );

                return this;

        }

        clone() {

                return new this.constructor().copy( this );

        }

        copy( box ) {

                this.min.copy( box.min );
                this.max.copy( box.max );

                return this;

        }

        makeEmpty() {

                this.min.x = this.min.y = + Infinity;
                this.max.x = this.max.y = - Infinity;

                return this;

        }

        isEmpty() {

                // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes

                return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );

        }

        getCenter( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Box2: .getCenter() target is now required' );
                        target = new Vector2();

                }

                return this.isEmpty() ? target.set( 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );

        }

        getSize( target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Box2: .getSize() target is now required' );
                        target = new Vector2();

                }

                return this.isEmpty() ? target.set( 0, 0 ) : target.subVectors( this.max, this.min );

        }

        expandByPoint( point ) {

                this.min.min( point );
                this.max.max( point );

                return this;

        }

        expandByVector( vector ) {

                this.min.sub( vector );
                this.max.add( vector );

                return this;

        }

        expandByScalar( scalar ) {

                this.min.addScalar( - scalar );
                this.max.addScalar( scalar );

                return this;

        }

        containsPoint( point ) {

                return point.x < this.min.x || point.x > this.max.x ||
                        point.y < this.min.y || point.y > this.max.y ? false : true;

        }

        containsBox( box ) {

                return this.min.x <= box.min.x && box.max.x <= this.max.x &&
                        this.min.y <= box.min.y && box.max.y <= this.max.y;

        }

        getParameter( point, target ) {

                // This can potentially have a divide by zero if the box
                // has a size dimension of 0.

                if ( target === undefined ) {

                        console.warn( 'THREE.Box2: .getParameter() target is now required' );
                        target = new Vector2();

                }

                return target.set(
                        ( point.x - this.min.x ) / ( this.max.x - this.min.x ),
                        ( point.y - this.min.y ) / ( this.max.y - this.min.y )
                );

        }

        intersectsBox( box ) {

                // using 4 splitting planes to rule out intersections

                return box.max.x < this.min.x || box.min.x > this.max.x ||
                        box.max.y < this.min.y || box.min.y > this.max.y ? false : true;

        }

        clampPoint( point, target ) {

                if ( target === undefined ) {

                        console.warn( 'THREE.Box2: .clampPoint() target is now required' );
                        target = new Vector2();

                }

                return target.copy( point ).clamp( this.min, this.max );

        }

        distanceToPoint( point ) {

                const clampedPoint = _vector$8.copy( point ).clamp( this.min, this.max );
                return clampedPoint.sub( point ).length();

        }

        intersect( box ) {

                this.min.max( box.min );
                this.max.min( box.max );

                return this;

        }

        union( box ) {

                this.min.min( box.min );
                this.max.max( box.max );

                return this;

        }

        translate( offset ) {

                this.min.add( offset );
                this.max.add( offset );

                return this;

        }

        equals( box ) {

                return box.min.equals( this.min ) && box.max.equals( this.max );

        }

    }

    function ImmediateRenderObject( material ) {

        Object3D.call( this );

        this.material = material;
        this.render = function ( /* renderCallback */ ) {};

        this.hasPositions = false;
        this.hasNormals = false;
        this.hasColors = false;
        this.hasUvs = false;

        this.positionArray = null;
        this.normalArray = null;
        this.colorArray = null;
        this.uvArray = null;

        this.count = 0;

    }

    ImmediateRenderObject.prototype = Object.create( Object3D.prototype );
    ImmediateRenderObject.prototype.constructor = ImmediateRenderObject;

    ImmediateRenderObject.prototype.isImmediateRenderObject = true;

    const backgroundMaterial = new MeshBasicMaterial( {
        side: BackSide,
        depthWrite: false,
        depthTest: false,
    } );
    new Mesh( new BoxGeometry(), backgroundMaterial );

    //

    Curve.create = function ( construct, getPoint ) {

        console.log( 'THREE.Curve.create() has been deprecated' );

        construct.prototype = Object.create( Curve.prototype );
        construct.prototype.constructor = construct;
        construct.prototype.getPoint = getPoint;

        return construct;

    };

    //

    Object.assign( Path.prototype, {

        fromPoints: function ( points ) {

                console.warn( 'THREE.Path: .fromPoints() has been renamed to .setFromPoints().' );
                return this.setFromPoints( points );

        }

    } );

    //

    function Spline( points ) {

        console.warn( 'THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.' );

        CatmullRomCurve3.call( this, points );
        this.type = 'catmullrom';

    }

    Spline.prototype = Object.create( CatmullRomCurve3.prototype );

    Object.assign( Spline.prototype, {

        initFromArray: function ( /* a */ ) {

                console.error( 'THREE.Spline: .initFromArray() has been removed.' );

        },
        getControlPointsArray: function ( /* optionalTarget */ ) {

                console.error( 'THREE.Spline: .getControlPointsArray() has been removed.' );

        },
        reparametrizeByArcLength: function ( /* samplingCoef */ ) {

                console.error( 'THREE.Spline: .reparametrizeByArcLength() has been removed.' );

        }

    } );

    //

    Object.assign( Loader.prototype, {

        extractUrlBase: function ( url ) {

                console.warn( 'THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.' );
                return LoaderUtils.extractUrlBase( url );

        }

    } );

    Loader.Handlers = {

        add: function ( /* regex, loader */ ) {

                console.error( 'THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.' );

        },

        get: function ( /* file */ ) {

                console.error( 'THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.' );

        }

    };

    //

    Object.assign( Box2.prototype, {

        center: function ( optionalTarget ) {

                console.warn( 'THREE.Box2: .center() has been renamed to .getCenter().' );
                return this.getCenter( optionalTarget );

        },
        empty: function () {

                console.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' );
                return this.isEmpty();

        },
        isIntersectionBox: function ( box ) {

                console.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' );
                return this.intersectsBox( box );

        },
        size: function ( optionalTarget ) {

                console.warn( 'THREE.Box2: .size() has been renamed to .getSize().' );
                return this.getSize( optionalTarget );

        }
    } );

    Object.assign( Box3.prototype, {

        center: function ( optionalTarget ) {

                console.warn( 'THREE.Box3: .center() has been renamed to .getCenter().' );
                return this.getCenter( optionalTarget );

        },
        empty: function () {

                console.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' );
                return this.isEmpty();

        },
        isIntersectionBox: function ( box ) {

                console.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' );
                return this.intersectsBox( box );

        },
        isIntersectionSphere: function ( sphere ) {

                console.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' );
                return this.intersectsSphere( sphere );

        },
        size: function ( optionalTarget ) {

                console.warn( 'THREE.Box3: .size() has been renamed to .getSize().' );
                return this.getSize( optionalTarget );

        }
    } );

    Object.assign( Sphere.prototype, {

        empty: function () {

                console.warn( 'THREE.Sphere: .empty() has been renamed to .isEmpty().' );
                return this.isEmpty();

        },

    } );

    Frustum.prototype.setFromMatrix = function ( m ) {

        console.warn( 'THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix().' );
        return this.setFromProjectionMatrix( m );

    };

    Object.assign( MathUtils, {

        random16: function () {

                console.warn( 'THREE.Math: .random16() has been deprecated. Use Math.random() instead.' );
                return Math.random();

        },

        nearestPowerOfTwo: function ( value ) {

                console.warn( 'THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().' );
                return MathUtils.floorPowerOfTwo( value );

        },

        nextPowerOfTwo: function ( value ) {

                console.warn( 'THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().' );
                return MathUtils.ceilPowerOfTwo( value );

        }

    } );

    Object.assign( Matrix3.prototype, {

        flattenToArrayOffset: function ( array, offset ) {

                console.warn( 'THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.' );
                return this.toArray( array, offset );

        },
        multiplyVector3: function ( vector ) {

                console.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' );
                return vector.applyMatrix3( this );

        },
        multiplyVector3Array: function ( /* a */ ) {

                console.error( 'THREE.Matrix3: .multiplyVector3Array() has been removed.' );

        },
        applyToBufferAttribute: function ( attribute ) {

                console.warn( 'THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead.' );
                return attribute.applyMatrix3( this );

        },
        applyToVector3Array: function ( /* array, offset, length */ ) {

                console.error( 'THREE.Matrix3: .applyToVector3Array() has been removed.' );

        },
        getInverse: function ( matrix ) {

                console.warn( 'THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead.' );
                return this.copy( matrix ).invert();

        }

    } );

    Object.assign( Matrix4.prototype, {

        extractPosition: function ( m ) {

                console.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' );
                return this.copyPosition( m );

        },
        flattenToArrayOffset: function ( array, offset ) {

                console.warn( 'THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.' );
                return this.toArray( array, offset );

        },
        getPosition: function () {

                console.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' );
                return new Vector3().setFromMatrixColumn( this, 3 );

        },
        setRotationFromQuaternion: function ( q ) {

                console.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' );
                return this.makeRotationFromQuaternion( q );

        },
        multiplyToArray: function () {

                console.warn( 'THREE.Matrix4: .multiplyToArray() has been removed.' );

        },
        multiplyVector3: function ( vector ) {

                console.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
                return vector.applyMatrix4( this );

        },
        multiplyVector4: function ( vector ) {

                console.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
                return vector.applyMatrix4( this );

        },
        multiplyVector3Array: function ( /* a */ ) {

                console.error( 'THREE.Matrix4: .multiplyVector3Array() has been removed.' );

        },
        rotateAxis: function ( v ) {

                console.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' );
                v.transformDirection( this );

        },
        crossVector: function ( vector ) {

                console.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
                return vector.applyMatrix4( this );

        },
        translate: function () {

                console.error( 'THREE.Matrix4: .translate() has been removed.' );

        },
        rotateX: function () {

                console.error( 'THREE.Matrix4: .rotateX() has been removed.' );

        },
        rotateY: function () {

                console.error( 'THREE.Matrix4: .rotateY() has been removed.' );

        },
        rotateZ: function () {

                console.error( 'THREE.Matrix4: .rotateZ() has been removed.' );

        },
        rotateByAxis: function () {

                console.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' );

        },
        applyToBufferAttribute: function ( attribute ) {

                console.warn( 'THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead.' );
                return attribute.applyMatrix4( this );

        },
        applyToVector3Array: function ( /* array, offset, length */ ) {

                console.error( 'THREE.Matrix4: .applyToVector3Array() has been removed.' );

        },
        makeFrustum: function ( left, right, bottom, top, near, far ) {

                console.warn( 'THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.' );
                return this.makePerspective( left, right, top, bottom, near, far );

        },
        getInverse: function ( matrix ) {

                console.warn( 'THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead.' );
                return this.copy( matrix ).invert();

        }

    } );

    Plane.prototype.isIntersectionLine = function ( line ) {

        console.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' );
        return this.intersectsLine( line );

    };

    Object.assign( Quaternion.prototype, {

        multiplyVector3: function ( vector ) {

                console.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' );
                return vector.applyQuaternion( this );

        },
        inverse: function ( ) {

                console.warn( 'THREE.Quaternion: .inverse() has been renamed to invert().' );
                return this.invert();

        }

    } );

    Object.assign( Ray.prototype, {

        isIntersectionBox: function ( box ) {

                console.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' );
                return this.intersectsBox( box );

        },
        isIntersectionPlane: function ( plane ) {

                console.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' );
                return this.intersectsPlane( plane );

        },
        isIntersectionSphere: function ( sphere ) {

                console.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' );
                return this.intersectsSphere( sphere );

        }

    } );

    Object.assign( Triangle.prototype, {

        area: function () {

                console.warn( 'THREE.Triangle: .area() has been renamed to .getArea().' );
                return this.getArea();

        },
        barycoordFromPoint: function ( point, target ) {

                console.warn( 'THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().' );
                return this.getBarycoord( point, target );

        },
        midpoint: function ( target ) {

                console.warn( 'THREE.Triangle: .midpoint() has been renamed to .getMidpoint().' );
                return this.getMidpoint( target );

        },
        normal: function ( target ) {

                console.warn( 'THREE.Triangle: .normal() has been renamed to .getNormal().' );
                return this.getNormal( target );

        },
        plane: function ( target ) {

                console.warn( 'THREE.Triangle: .plane() has been renamed to .getPlane().' );
                return this.getPlane( target );

        }

    } );

    Object.assign( Triangle, {

        barycoordFromPoint: function ( point, a, b, c, target ) {

                console.warn( 'THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().' );
                return Triangle.getBarycoord( point, a, b, c, target );

        },
        normal: function ( a, b, c, target ) {

                console.warn( 'THREE.Triangle: .normal() has been renamed to .getNormal().' );
                return Triangle.getNormal( a, b, c, target );

        }

    } );

    Object.assign( Shape.prototype, {

        extractAllPoints: function ( divisions ) {

                console.warn( 'THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.' );
                return this.extractPoints( divisions );

        },
        extrude: function ( options ) {

                console.warn( 'THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.' );
                return new ExtrudeGeometry( this, options );

        },
        makeGeometry: function ( options ) {

                console.warn( 'THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.' );
                return new ShapeGeometry( this, options );

        }

    } );

    Object.assign( Vector2.prototype, {

        fromAttribute: function ( attribute, index, offset ) {

                console.warn( 'THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().' );
                return this.fromBufferAttribute( attribute, index, offset );

        },
        distanceToManhattan: function ( v ) {

                console.warn( 'THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' );
                return this.manhattanDistanceTo( v );

        },
        lengthManhattan: function () {

                console.warn( 'THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().' );
                return this.manhattanLength();

        }

    } );

    Object.assign( Vector3.prototype, {

        setEulerFromRotationMatrix: function () {

                console.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' );

        },
        setEulerFromQuaternion: function () {

                console.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' );

        },
        getPositionFromMatrix: function ( m ) {

                console.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' );
                return this.setFromMatrixPosition( m );

        },
        getScaleFromMatrix: function ( m ) {

                console.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' );
                return this.setFromMatrixScale( m );

        },
        getColumnFromMatrix: function ( index, matrix ) {

                console.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' );
                return this.setFromMatrixColumn( matrix, index );

        },
        applyProjection: function ( m ) {

                console.warn( 'THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.' );
                return this.applyMatrix4( m );

        },
        fromAttribute: function ( attribute, index, offset ) {

                console.warn( 'THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().' );
                return this.fromBufferAttribute( attribute, index, offset );

        },
        distanceToManhattan: function ( v ) {

                console.warn( 'THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' );
                return this.manhattanDistanceTo( v );

        },
        lengthManhattan: function () {

                console.warn( 'THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().' );
                return this.manhattanLength();

        }

    } );

    Object.assign( Vector4.prototype, {

        fromAttribute: function ( attribute, index, offset ) {

                console.warn( 'THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().' );
                return this.fromBufferAttribute( attribute, index, offset );

        },
        lengthManhattan: function () {

                console.warn( 'THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().' );
                return this.manhattanLength();

        }

    } );

    //

    Object.assign( Object3D.prototype, {

        getChildByName: function ( name ) {

                console.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' );
                return this.getObjectByName( name );

        },
        renderDepth: function () {

                console.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' );

        },
        translate: function ( distance, axis ) {

                console.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' );
                return this.translateOnAxis( axis, distance );

        },
        getWorldRotation: function () {

                console.error( 'THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.' );

        },
        applyMatrix: function ( matrix ) {

                console.warn( 'THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4().' );
                return this.applyMatrix4( matrix );

        }

    } );

    Object.defineProperties( Object3D.prototype, {

        eulerOrder: {
                get: function () {

                        console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );
                        return this.rotation.order;

                },
                set: function ( value ) {

                        console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );
                        this.rotation.order = value;

                }
        },
        useQuaternion: {
                get: function () {

                        console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );

                },
                set: function () {

                        console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );

                }
        }

    } );

    Object.assign( Mesh.prototype, {

        setDrawMode: function () {

                console.error( 'THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.' );

        },

    } );

    Object.defineProperties( Mesh.prototype, {

        drawMode: {
                get: function () {

                        console.error( 'THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode.' );
                        return TrianglesDrawMode;

                },
                set: function () {

                        console.error( 'THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.' );

                }
        }

    } );

    Object.defineProperties( LOD.prototype, {

        objects: {
                get: function () {

                        console.warn( 'THREE.LOD: .objects has been renamed to .levels.' );
                        return this.levels;

                }
        }

    } );

    Object.defineProperty( Skeleton.prototype, 'useVertexTexture', {

        get: function () {

                console.warn( 'THREE.Skeleton: useVertexTexture has been removed.' );

        },
        set: function () {

                console.warn( 'THREE.Skeleton: useVertexTexture has been removed.' );

        }

    } );

    SkinnedMesh.prototype.initBones = function () {

        console.error( 'THREE.SkinnedMesh: initBones() has been removed.' );

    };

    Object.defineProperty( Curve.prototype, '__arcLengthDivisions', {

        get: function () {

                console.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' );
                return this.arcLengthDivisions;

        },
        set: function ( value ) {

                console.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' );
                this.arcLengthDivisions = value;

        }

    } );

    //

    PerspectiveCamera.prototype.setLens = function ( focalLength, filmGauge ) {

        console.warn( 'THREE.PerspectiveCamera.setLens is deprecated. ' +
                        'Use .setFocalLength and .filmGauge for a photographic setup.' );

        if ( filmGauge !== undefined ) this.filmGauge = filmGauge;
        this.setFocalLength( focalLength );

    };

    //

    Object.defineProperties( Light.prototype, {
        onlyShadow: {
                set: function () {

                        console.warn( 'THREE.Light: .onlyShadow has been removed.' );

                }
        },
        shadowCameraFov: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraFov is now .shadow.camera.fov.' );
                        this.shadow.camera.fov = value;

                }
        },
        shadowCameraLeft: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraLeft is now .shadow.camera.left.' );
                        this.shadow.camera.left = value;

                }
        },
        shadowCameraRight: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraRight is now .shadow.camera.right.' );
                        this.shadow.camera.right = value;

                }
        },
        shadowCameraTop: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraTop is now .shadow.camera.top.' );
                        this.shadow.camera.top = value;

                }
        },
        shadowCameraBottom: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.' );
                        this.shadow.camera.bottom = value;

                }
        },
        shadowCameraNear: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraNear is now .shadow.camera.near.' );
                        this.shadow.camera.near = value;

                }
        },
        shadowCameraFar: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowCameraFar is now .shadow.camera.far.' );
                        this.shadow.camera.far = value;

                }
        },
        shadowCameraVisible: {
                set: function () {

                        console.warn( 'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.' );

                }
        },
        shadowBias: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowBias is now .shadow.bias.' );
                        this.shadow.bias = value;

                }
        },
        shadowDarkness: {
                set: function () {

                        console.warn( 'THREE.Light: .shadowDarkness has been removed.' );

                }
        },
        shadowMapWidth: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.' );
                        this.shadow.mapSize.width = value;

                }
        },
        shadowMapHeight: {
                set: function ( value ) {

                        console.warn( 'THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.' );
                        this.shadow.mapSize.height = value;

                }
        }
    } );

    //

    Object.defineProperties( BufferAttribute.prototype, {

        length: {
                get: function () {

                        console.warn( 'THREE.BufferAttribute: .length has been deprecated. Use .count instead.' );
                        return this.array.length;

                }
        },
        dynamic: {
                get: function () {

                        console.warn( 'THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead.' );
                        return this.usage === DynamicDrawUsage;

                },
                set: function ( /* value */ ) {

                        console.warn( 'THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead.' );
                        this.setUsage( DynamicDrawUsage );

                }
        }

    } );

    Object.assign( BufferAttribute.prototype, {
        setDynamic: function ( value ) {

                console.warn( 'THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead.' );
                this.setUsage( value === true ? DynamicDrawUsage : StaticDrawUsage );
                return this;

        },
        copyIndicesArray: function ( /* indices */ ) {

                console.error( 'THREE.BufferAttribute: .copyIndicesArray() has been removed.' );

        },
        setArray: function ( /* array */ ) {

                console.error( 'THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers' );

        }
    } );

    Object.assign( BufferGeometry.prototype, {

        addIndex: function ( index ) {

                console.warn( 'THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().' );
                this.setIndex( index );

        },
        addAttribute: function ( name, attribute ) {

                console.warn( 'THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute().' );

                if ( ! ( attribute && attribute.isBufferAttribute ) && ! ( attribute && attribute.isInterleavedBufferAttribute ) ) {

                        console.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' );

                        return this.setAttribute( name, new BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) );

                }

                if ( name === 'index' ) {

                        console.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' );
                        this.setIndex( attribute );

                        return this;

                }

                return this.setAttribute( name, attribute );

        },
        addDrawCall: function ( start, count, indexOffset ) {

                if ( indexOffset !== undefined ) {

                        console.warn( 'THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.' );

                }

                console.warn( 'THREE.BufferGeometry: .addDrawCall() is now .addGroup().' );
                this.addGroup( start, count );

        },
        clearDrawCalls: function () {

                console.warn( 'THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().' );
                this.clearGroups();

        },
        computeOffsets: function () {

                console.warn( 'THREE.BufferGeometry: .computeOffsets() has been removed.' );

        },
        removeAttribute: function ( name ) {

                console.warn( 'THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute().' );

                return this.deleteAttribute( name );

        },
        applyMatrix: function ( matrix ) {

                console.warn( 'THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4().' );
                return this.applyMatrix4( matrix );

        }

    } );

    Object.defineProperties( BufferGeometry.prototype, {

        drawcalls: {
                get: function () {

                        console.error( 'THREE.BufferGeometry: .drawcalls has been renamed to .groups.' );
                        return this.groups;

                }
        },
        offsets: {
                get: function () {

                        console.warn( 'THREE.BufferGeometry: .offsets has been renamed to .groups.' );
                        return this.groups;

                }
        }

    } );

    Object.defineProperties( InstancedBufferGeometry.prototype, {

        maxInstancedCount: {
                get: function () {

                        console.warn( 'THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount.' );
                        return this.instanceCount;

                },
                set: function ( value ) {

                        console.warn( 'THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount.' );
                        this.instanceCount = value;

                }
        }

    } );

    Object.defineProperties( Raycaster.prototype, {

        linePrecision: {
                get: function () {

                        console.warn( 'THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead.' );
                        return this.params.Line.threshold;

                },
                set: function ( value ) {

                        console.warn( 'THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead.' );
                        this.params.Line.threshold = value;

                }
        }

    } );

    Object.defineProperties( InterleavedBuffer.prototype, {

        dynamic: {
                get: function () {

                        console.warn( 'THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead.' );
                        return this.usage === DynamicDrawUsage;

                },
                set: function ( value ) {

                        console.warn( 'THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead.' );
                        this.setUsage( value );

                }
        }

    } );

    Object.assign( InterleavedBuffer.prototype, {
        setDynamic: function ( value ) {

                console.warn( 'THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead.' );
                this.setUsage( value === true ? DynamicDrawUsage : StaticDrawUsage );
                return this;

        },
        setArray: function ( /* array */ ) {

                console.error( 'THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers' );

        }
    } );

    //

    Object.assign( ExtrudeGeometry.prototype, {

        getArrays: function () {

                console.error( 'THREE.ExtrudeGeometry: .getArrays() has been removed.' );

        },

        addShapeList: function () {

                console.error( 'THREE.ExtrudeGeometry: .addShapeList() has been removed.' );

        },

        addShape: function () {

                console.error( 'THREE.ExtrudeGeometry: .addShape() has been removed.' );

        }

    } );

    //

    Object.assign( Scene.prototype, {

        dispose: function () {

                console.error( 'THREE.Scene: .dispose() has been removed.' );

        }

    } );

    //

    Object.defineProperties( Uniform.prototype, {

        dynamic: {
                set: function () {

                        console.warn( 'THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.' );

                }
        },
        onUpdate: {
                value: function () {

                        console.warn( 'THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.' );
                        return this;

                }
        }

    } );

    //

    Object.defineProperties( Material.prototype, {

        wrapAround: {
                get: function () {

                        console.warn( 'THREE.Material: .wrapAround has been removed.' );

                },
                set: function () {

                        console.warn( 'THREE.Material: .wrapAround has been removed.' );

                }
        },

        overdraw: {
                get: function () {

                        console.warn( 'THREE.Material: .overdraw has been removed.' );

                },
                set: function () {

                        console.warn( 'THREE.Material: .overdraw has been removed.' );

                }
        },

        wrapRGB: {
                get: function () {

                        console.warn( 'THREE.Material: .wrapRGB has been removed.' );
                        return new Color();

                }
        },

        shading: {
                get: function () {

                        console.error( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );

                },
                set: function ( value ) {

                        console.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );
                        this.flatShading = ( value === FlatShading );

                }
        },

        stencilMask: {
                get: function () {

                        console.warn( 'THREE.' + this.type + ': .stencilMask has been removed. Use .stencilFuncMask instead.' );
                        return this.stencilFuncMask;

                },
                set: function ( value ) {

                        console.warn( 'THREE.' + this.type + ': .stencilMask has been removed. Use .stencilFuncMask instead.' );
                        this.stencilFuncMask = value;

                }
        }

    } );

    Object.defineProperties( MeshPhongMaterial.prototype, {

        metal: {
                get: function () {

                        console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.' );
                        return false;

                },
                set: function () {

                        console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead' );

                }
        }

    } );

    Object.defineProperties( MeshPhysicalMaterial.prototype, {

        transparency: {
                get: function () {

                        console.warn( 'THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission.' );
                        return this.transmission;

                },
                set: function ( value ) {

                        console.warn( 'THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission.' );
                        this.transmission = value;

                }
        }

    } );

    Object.defineProperties( ShaderMaterial.prototype, {

        derivatives: {
                get: function () {

                        console.warn( 'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );
                        return this.extensions.derivatives;

                },
                set: function ( value ) {

                        console.warn( 'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );
                        this.extensions.derivatives = value;

                }
        }

    } );

    //

    Object.assign( WebGLRenderer.prototype, {

        clearTarget: function ( renderTarget, color, depth, stencil ) {

                console.warn( 'THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead.' );
                this.setRenderTarget( renderTarget );
                this.clear( color, depth, stencil );

        },
        animate: function ( callback ) {

                console.warn( 'THREE.WebGLRenderer: .animate() is now .setAnimationLoop().' );
                this.setAnimationLoop( callback );

        },
        getCurrentRenderTarget: function () {

                console.warn( 'THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().' );
                return this.getRenderTarget();

        },
        getMaxAnisotropy: function () {

                console.warn( 'THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().' );
                return this.capabilities.getMaxAnisotropy();

        },
        getPrecision: function () {

                console.warn( 'THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.' );
                return this.capabilities.precision;

        },
        resetGLState: function () {

                console.warn( 'THREE.WebGLRenderer: .resetGLState() is now .state.reset().' );
                return this.state.reset();

        },
        supportsFloatTextures: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \'OES_texture_float\' ).' );
                return this.extensions.get( 'OES_texture_float' );

        },
        supportsHalfFloatTextures: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( \'OES_texture_half_float\' ).' );
                return this.extensions.get( 'OES_texture_half_float' );

        },
        supportsStandardDerivatives: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( \'OES_standard_derivatives\' ).' );
                return this.extensions.get( 'OES_standard_derivatives' );

        },
        supportsCompressedTextureS3TC: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( \'WEBGL_compressed_texture_s3tc\' ).' );
                return this.extensions.get( 'WEBGL_compressed_texture_s3tc' );

        },
        supportsCompressedTexturePVRTC: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( \'WEBGL_compressed_texture_pvrtc\' ).' );
                return this.extensions.get( 'WEBGL_compressed_texture_pvrtc' );

        },
        supportsBlendMinMax: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( \'EXT_blend_minmax\' ).' );
                return this.extensions.get( 'EXT_blend_minmax' );

        },
        supportsVertexTextures: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.' );
                return this.capabilities.vertexTextures;

        },
        supportsInstancedArrays: function () {

                console.warn( 'THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( \'ANGLE_instanced_arrays\' ).' );
                return this.extensions.get( 'ANGLE_instanced_arrays' );

        },
        enableScissorTest: function ( boolean ) {

                console.warn( 'THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().' );
                this.setScissorTest( boolean );

        },
        initMaterial: function () {

                console.warn( 'THREE.WebGLRenderer: .initMaterial() has been removed.' );

        },
        addPrePlugin: function () {

                console.warn( 'THREE.WebGLRenderer: .addPrePlugin() has been removed.' );

        },
        addPostPlugin: function () {

                console.warn( 'THREE.WebGLRenderer: .addPostPlugin() has been removed.' );

        },
        updateShadowMap: function () {

                console.warn( 'THREE.WebGLRenderer: .updateShadowMap() has been removed.' );

        },
        setFaceCulling: function () {

                console.warn( 'THREE.WebGLRenderer: .setFaceCulling() has been removed.' );

        },
        allocTextureUnit: function () {

                console.warn( 'THREE.WebGLRenderer: .allocTextureUnit() has been removed.' );

        },
        setTexture: function () {

                console.warn( 'THREE.WebGLRenderer: .setTexture() has been removed.' );

        },
        setTexture2D: function () {

                console.warn( 'THREE.WebGLRenderer: .setTexture2D() has been removed.' );

        },
        setTextureCube: function () {

                console.warn( 'THREE.WebGLRenderer: .setTextureCube() has been removed.' );

        },
        getActiveMipMapLevel: function () {

                console.warn( 'THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel().' );
                return this.getActiveMipmapLevel();

        }

    } );

    Object.defineProperties( WebGLRenderer.prototype, {

        shadowMapEnabled: {
                get: function () {

                        return this.shadowMap.enabled;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.' );
                        this.shadowMap.enabled = value;

                }
        },
        shadowMapType: {
                get: function () {

                        return this.shadowMap.type;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.' );
                        this.shadowMap.type = value;

                }
        },
        shadowMapCullFace: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.' );
                        return undefined;

                },
                set: function ( /* value */ ) {

                        console.warn( 'THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.' );

                }
        },
        context: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .context has been removed. Use .getContext() instead.' );
                        return this.getContext();

                }
        },
        vr: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .vr has been renamed to .xr' );
                        return this.xr;

                }
        },
        gammaInput: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.' );
                        return false;

                },
                set: function () {

                        console.warn( 'THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.' );

                }
        },
        gammaOutput: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead.' );
                        return false;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead.' );
                        this.outputEncoding = ( value === true ) ? sRGBEncoding : LinearEncoding;

                }
        },
        toneMappingWhitePoint: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.' );
                        return 1.0;

                },
                set: function () {

                        console.warn( 'THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.' );

                }
        },

    } );

    Object.defineProperties( WebGLShadowMap.prototype, {

        cullFace: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.' );
                        return undefined;

                },
                set: function ( /* cullFace */ ) {

                        console.warn( 'THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.' );

                }
        },
        renderReverseSided: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.' );
                        return undefined;

                },
                set: function () {

                        console.warn( 'THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.' );

                }
        },
        renderSingleSided: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.' );
                        return undefined;

                },
                set: function () {

                        console.warn( 'THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.' );

                }
        }

    } );

    //

    Object.defineProperties( WebGLRenderTarget.prototype, {

        wrapS: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );
                        return this.texture.wrapS;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );
                        this.texture.wrapS = value;

                }
        },
        wrapT: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );
                        return this.texture.wrapT;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );
                        this.texture.wrapT = value;

                }
        },
        magFilter: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );
                        return this.texture.magFilter;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );
                        this.texture.magFilter = value;

                }
        },
        minFilter: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );
                        return this.texture.minFilter;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );
                        this.texture.minFilter = value;

                }
        },
        anisotropy: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );
                        return this.texture.anisotropy;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );
                        this.texture.anisotropy = value;

                }
        },
        offset: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );
                        return this.texture.offset;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );
                        this.texture.offset = value;

                }
        },
        repeat: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );
                        return this.texture.repeat;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );
                        this.texture.repeat = value;

                }
        },
        format: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );
                        return this.texture.format;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );
                        this.texture.format = value;

                }
        },
        type: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );
                        return this.texture.type;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );
                        this.texture.type = value;

                }
        },
        generateMipmaps: {
                get: function () {

                        console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );
                        return this.texture.generateMipmaps;

                },
                set: function ( value ) {

                        console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );
                        this.texture.generateMipmaps = value;

                }
        }

    } );

    //

    Object.defineProperties( Audio.prototype, {

        load: {
                value: function ( file ) {

                        console.warn( 'THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.' );
                        const scope = this;
                        const audioLoader = new AudioLoader();
                        audioLoader.load( file, function ( buffer ) {

                                scope.setBuffer( buffer );

                        } );
                        return this;

                }
        },
        startTime: {
                set: function () {

                        console.warn( 'THREE.Audio: .startTime is now .play( delay ).' );

                }
        }

    } );

    //

    CubeCamera.prototype.updateCubeMap = function ( renderer, scene ) {

        console.warn( 'THREE.CubeCamera: .updateCubeMap() is now .update().' );
        return this.update( renderer, scene );

    };

    CubeCamera.prototype.clear = function ( renderer, color, depth, stencil ) {

        console.warn( 'THREE.CubeCamera: .clear() is now .renderTarget.clear().' );
        return this.renderTarget.clear( renderer, color, depth, stencil );

    };

    ImageUtils.crossOrigin = undefined;

    ImageUtils.loadTexture = function ( url, mapping, onLoad, onError ) {

        console.warn( 'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.' );

        const loader = new TextureLoader();
        loader.setCrossOrigin( this.crossOrigin );

        const texture = loader.load( url, onLoad, undefined, onError );

        if ( mapping ) texture.mapping = mapping;

        return texture;

    };

    ImageUtils.loadTextureCube = function ( urls, mapping, onLoad, onError ) {

        console.warn( 'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.' );

        const loader = new CubeTextureLoader();
        loader.setCrossOrigin( this.crossOrigin );

        const texture = loader.load( urls, onLoad, undefined, onError );

        if ( mapping ) texture.mapping = mapping;

        return texture;

    };

    ImageUtils.loadCompressedTexture = function () {

        console.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.' );

    };

    ImageUtils.loadCompressedTextureCube = function () {

        console.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' );

    };

    if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {

        /* eslint-disable no-undef */
        __THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'register', { detail: {
                revision: REVISION,
        } } ) );
        /* eslint-enable no-undef */

    }

    if ( typeof window !== 'undefined' ) {

        if ( window.__THREE__ ) {

                console.warn( 'WARNING: Multiple instances of Three.js being imported.' );

        } else {

                window.__THREE__ = REVISION;

        }

    }

    const DEG2RAD = Math.PI / 180;
    const RAD2DEG = 180 / Math.PI;
    const WGS84A = 6378137.0;
    const WGS84B = 6356752.31424518;
    /**
     * Convert coordinates from geodetic (WGS84) reference to local topocentric
     * (ENU) reference.
     *
     * @param {number} lng Longitude in degrees.
     * @param {number} lat Latitude in degrees.
     * @param {number} alt Altitude in meters.
     * @param {number} refLng Reference longitude in degrees.
     * @param {number} refLat Reference latitude in degrees.
     * @param {number} refAlt Reference altitude in meters.
     * @returns {Array<number>} The x, y, z local topocentric ENU coordinates.
     */
    function geodeticToEnu(lng, lat, alt, refLng, refLat, refAlt) {
        const ecef = geodeticToEcef(lng, lat, alt);
        return ecefToEnu(ecef[0], ecef[1], ecef[2], refLng, refLat, refAlt);
    }
    /**
     * Convert coordinates from local topocentric (ENU) reference to
     * geodetic (WGS84) reference.
     *
     * @param {number} x Topocentric ENU coordinate in East direction.
     * @param {number} y Topocentric ENU coordinate in North direction.
     * @param {number} z Topocentric ENU coordinate in Up direction.
     * @param {number} refLng Reference longitude in degrees.
     * @param {number} refLat Reference latitude in degrees.
     * @param {number} refAlt Reference altitude in meters.
     * @returns {Array<number>} The longitude, latitude in degrees
     * and altitude in meters.
     */
    function enuToGeodetic(x, y, z, refLng, refLat, refAlt) {
        const ecef = enuToEcef(x, y, z, refLng, refLat, refAlt);
        return ecefToGeodetic(ecef[0], ecef[1], ecef[2]);
    }
    /**
     * Convert coordinates from Earth-Centered, Earth-Fixed (ECEF) reference
     * to local topocentric (ENU) reference.
     *
     * @param {number} X ECEF X-value.
     * @param {number} Y ECEF Y-value.
     * @param {number} Z ECEF Z-value.
     * @param {number} refLng Reference longitude in degrees.
     * @param {number} refLat Reference latitude in degrees.
     * @param {number} refAlt Reference altitude in meters.
     * @returns {Array<number>} The x, y, z topocentric ENU coordinates in East, North
     * and Up directions respectively.
     */
    function ecefToEnu(X, Y, Z, refLng, refLat, refAlt) {
        const refEcef = geodeticToEcef(refLng, refLat, refAlt);
        const V = [
            X - refEcef[0],
            Y - refEcef[1],
            Z - refEcef[2],
        ];
        refLng = refLng * DEG2RAD;
        refLat = refLat * DEG2RAD;
        const cosLng = Math.cos(refLng);
        const sinLng = Math.sin(refLng);
        const cosLat = Math.cos(refLat);
        const sinLat = Math.sin(refLat);
        const x = -sinLng * V[0] + cosLng * V[1];
        const y = -sinLat * cosLng * V[0] - sinLat * sinLng * V[1] + cosLat * V[2];
        const z = cosLat * cosLng * V[0] + cosLat * sinLng * V[1] + sinLat * V[2];
        return [x, y, z];
    }
    /**
     * Convert coordinates from local topocentric (ENU) reference
     * to Earth-Centered, Earth-Fixed (ECEF) reference.
     *
     * @param {number} x Topocentric ENU coordinate in East direction.
     * @param {number} y Topocentric ENU coordinate in North direction.
     * @param {number} z Topocentric ENU coordinate in Up direction.
     * @param {number} refLng Reference longitude in degrees.
     * @param {number} refLat Reference latitude in degrees.
     * @param {number} refAlt Reference altitude in meters.
     * @returns {Array<number>} The X, Y, Z ECEF coordinates.
     */
    function enuToEcef(x, y, z, refLng, refLat, refAlt) {
        const refEcef = geodeticToEcef(refLng, refLat, refAlt);
        refLng = refLng * DEG2RAD;
        refLat = refLat * DEG2RAD;
        const cosLng = Math.cos(refLng);
        const sinLng = Math.sin(refLng);
        const cosLat = Math.cos(refLat);
        const sinLat = Math.sin(refLat);
        const X = -sinLng * x
            - sinLat * cosLng * y
            + cosLat * cosLng * z
            + refEcef[0];
        const Y = cosLng * x
            - sinLat * sinLng * y
            + cosLat * sinLng * z
            + refEcef[1];
        const Z = cosLat * y +
            sinLat * z +
            refEcef[2];
        return [X, Y, Z];
    }
    /**
     * Convert coordinates from geodetic reference (WGS84) to Earth-Centered,
     * Earth-Fixed (ECEF) reference.
     *
     * @param {number} lng Longitude in degrees.
     * @param {number} lat Latitude in degrees.
     * @param {number} alt Altitude in meters.
     * @returns {Array<number>} The X, Y, Z ECEF coordinates.
     */
    function geodeticToEcef(lng, lat, alt) {
        const a = WGS84A;
        const b = WGS84B;
        lng = lng * DEG2RAD;
        lat = lat * DEG2RAD;
        const cosLng = Math.cos(lng);
        const sinLng = Math.sin(lng);
        const cosLat = Math.cos(lat);
        const sinLat = Math.sin(lat);
        const a2 = a * a;
        const b2 = b * b;
        const L = 1.0 / Math.sqrt(a2 * cosLat * cosLat + b2 * sinLat * sinLat);
        const nhcl = (a2 * L + alt) * cosLat;
        const X = nhcl * cosLng;
        const Y = nhcl * sinLng;
        const Z = (b2 * L + alt) * sinLat;
        return [X, Y, Z];
    }
    /**
     * Convert coordinates from Earth-Centered, Earth-Fixed (ECEF) reference
     * to geodetic reference (WGS84).
     *
     * @param {number} X ECEF X-value.
     * @param {number} Y ECEF Y-value.
     * @param {number} Z ECEF Z-value.
     * @returns {Array<number>} The longitude, latitude in degrees
     * and altitude in meters.
     */
    function ecefToGeodetic(X, Y, Z) {
        const a = WGS84A;
        const b = WGS84B;
        const a2 = a * a;
        const b2 = b * b;
        const a2mb2 = a2 - b2;
        const ea = Math.sqrt(a2mb2 / a2);
        const eb = Math.sqrt(a2mb2 / b2);
        const p = Math.sqrt(X * X + Y * Y);
        const theta = Math.atan2(Z * a, p * b);
        const sinTheta = Math.sin(theta);
        const cosTheta = Math.cos(theta);
        const lng = Math.atan2(Y, X);
        const lat = Math.atan2(Z + eb * eb * b * sinTheta * sinTheta * sinTheta, p - ea * ea * a * cosTheta * cosTheta * cosTheta);
        const sinLat = Math.sin(lat);
        const cosLat = Math.cos(lat);
        const N = a / Math.sqrt(1 - ea * ea * sinLat * sinLat);
        const alt = p / cosLat - N;
        return [
            lng * RAD2DEG,
            lat * RAD2DEG,
            alt
        ];
    }

    /**
     * @class GraphCalculator
     *
     * @classdesc Represents a calculator for graph entities.
     */
    class GraphCalculator {
        /**
         * Get the bounding box corners for a circle with radius of a threshold
         * with center in a geodetic position.
         *
         * @param {LngLat} lngLat - Longitude, latitude to encode.
         * @param {number} threshold - Threshold distance from the position in meters.
         *
         * @returns {Array<LngLat>} The south west and north east corners of the
         * bounding box.
         */
        boundingBoxCorners(lngLat, threshold) {
            const sw = enuToGeodetic(-threshold, -threshold, 0, lngLat.lng, lngLat.lat, 0);
            const ne = enuToGeodetic(threshold, threshold, 0, lngLat.lng, lngLat.lat, 0);
            return [
                { lat: sw[1], lng: sw[0] },
                { lat: ne[1], lng: ne[0] },
            ];
        }
        /**
         * Convert a compass angle to an angle axis rotation vector.
         *
         * @param {number} compassAngle - The compass angle in degrees.
         * @param {number} orientation - The orientation of the original image.
         *
         * @returns {Array<number>} Angle axis rotation vector.
         */
        rotationFromCompass(compassAngle, orientation) {
            let x = 0;
            let y = 0;
            let z = 0;
            switch (orientation) {
                case 1:
                    x = Math.PI / 2;
                    break;
                case 3:
                    x = -Math.PI / 2;
                    z = Math.PI;
                    break;
                case 6:
                    y = -Math.PI / 2;
                    z = -Math.PI / 2;
                    break;
                case 8:
                    y = Math.PI / 2;
                    z = Math.PI / 2;
                    break;
            }
            const rz = new Matrix4()
                .makeRotationZ(z);
            const euler = new Euler(x, y, compassAngle * Math.PI / 180, "XYZ");
            const re = new Matrix4()
                .makeRotationFromEuler(euler);
            const rotation = new Vector4()
                .setAxisAngleFromRotationMatrix(re.multiply(rz));
            return rotation
                .multiplyScalar(rotation.w)
                .toArray()
                .slice(0, 3);
        }
    }

    /**
     * @class Image
     *
     * @classdesc Represents a image in the navigation graph.
     *
     * Explanation of position and bearing properties:
     *
     * When images are uploaded they will have GPS information in the EXIF, this is what
     * is called `originalLngLat` {@link Image.originalLngLat}.
     *
     * When Structure from Motions has been run for a image a `computedLngLat` that
     * differs from the `originalLngLat` will be created. It is different because
     * GPS positions are not very exact and SfM aligns the camera positions according
     * to the 3D reconstruction {@link Image.computedLngLat}.
     *
     * At last there exist a `lngLat` property which evaluates to
     * the `computedLngLat` from SfM if it exists but falls back
     * to the `originalLngLat` from the EXIF GPS otherwise {@link Image.lngLat}.
     *
     * Everything that is done in in the Viewer is based on the SfM positions,
     * i.e. `computedLngLat`. That is why the smooth transitions go in the right
     * direction (nd not in strange directions because of bad GPS).
     *
     * E.g. when placing a marker in the Viewer it is relative to the SfM
     * position i.e. the `computedLngLat`.
     *
     * The same concept as above also applies to the compass angle (or bearing) properties
     * `originalCa`, `computedCa` and `ca`.
     */
    class Image$1 {
        /**
         * Create a new image instance.
         *
         * @description Images are always created internally by the library.
         * Images can not be added to the library through any API method.
         *
         * @param {CoreImageEnt} core- Raw core image data.
         * @ignore
         */
        constructor(core) {
            if (!core) {
                throw new Error(`Incorrect core image data ${core}`);
            }
            this._cache = null;
            this._core = core;
            this._spatial = null;
        }
        /**
         * Get assets cached.
         *
         * @description The assets that need to be cached for this property
         * to report true are the following: fill properties, image and mesh.
         * The library ensures that the current image will always have the
         * assets cached.
         *
         * @returns {boolean} Value indicating whether all assets have been
         * cached.
         *
         * @ignore
         */
        get assetsCached() {
            return this._core != null &&
                this._spatial != null &&
                this._cache != null &&
                this._cache.image != null &&
                this._cache.mesh != null;
        }
        /**
         * Get cameraParameters.
         *
         * @description Will be undefined if SfM has
         * not been run.
         *
         * Camera type dependent parameters.
         *
         * For perspective and fisheye camera types,
         * the camera parameters array should be
         * constructed according to
         *
         * `[focal, k1, k2]`
         *
         * where focal is the camera focal length,
         * and k1, k2 are radial distortion parameters.
         *
         * For spherical camera type the camera
         * parameters are unset or emtpy array.
         *
         * @returns {Array<number>} The parameters
         * related to the camera type.
         */
        get cameraParameters() {
            return this._spatial.camera_parameters;
        }
        /**
         * Get cameraType.
         *
         * @description Will be undefined if SfM has not been run.
         *
         * @returns {string} The camera type that captured the image.
         */
        get cameraType() {
            return this._spatial.camera_type;
        }
        /**
         * Get capturedAt.
         *
         * @description Timestamp of the image capture date
         * and time represented as a Unix epoch timestamp in milliseconds.
         *
         * @returns {number} Timestamp when the image was captured.
         */
        get capturedAt() {
            return this._spatial.captured_at;
        }
        /**
         * Get clusterId.
         *
         * @returns {string} Globally unique id of the SfM cluster to which
         * the image belongs.
         */
        get clusterId() {
            return !!this._spatial.cluster ?
                this._spatial.cluster.id :
                null;
        }
        /**
         * Get clusterUrl.
         *
         * @returns {string} Url to the cluster reconstruction file.
         *
         * @ignore
         */
        get clusterUrl() {
            return !!this._spatial.cluster ?
                this._spatial.cluster.url :
                null;
        }
        /**
         * Get compassAngle.
         *
         * @description If the SfM computed compass angle exists it will
         * be returned, otherwise the original EXIF compass angle.
         *
         * @returns {number} Compass angle, measured in degrees
         * clockwise with respect to north.
         */
        get compassAngle() {
            return this._spatial.computed_compass_angle != null ?
                this._spatial.computed_compass_angle :
                this._spatial.compass_angle;
        }
        /**
         * Get complete.
         *
         * @description The library ensures that the current image will
         * always be full.
         *
         * @returns {boolean} Value indicating whether the image has all
         * properties filled.
         *
         * @ignore
         */
        get complete() {
            return this._spatial != null;
        }
        /**
         * Get computedAltitude.
         *
         * @description If SfM has not been run the computed altitude is
         * set to a default value of two meters.
         *
         * @returns {number} Altitude, in meters.
         */
        get computedAltitude() {
            return this._spatial.computed_altitude;
        }
        /**
         * Get computedCompassAngle.
         *
         * @description Will not be set if SfM has not been run.
         *
         * @returns {number} SfM computed compass angle, measured
         * in degrees clockwise with respect to north.
         */
        get computedCompassAngle() {
            return this._spatial.computed_compass_angle;
        }
        /**
         * Get computedLngLat.
         *
         * @description Will not be set if SfM has not been run.
         *
         * @returns {LngLat} SfM computed longitude, latitude in WGS84 datum,
         * measured in degrees.
         */
        get computedLngLat() {
            return this._core.computed_geometry;
        }
        /**
         * Get creatorId.
         *
         * @description Note that the creator ID will not be set when using
         * the Mapillary API.
         *
         * @returns {string} Globally unique id of the user who uploaded
         * the image.
         */
        get creatorId() {
            return this._spatial.creator.id;
        }
        /**
         * Get creatorUsername.
         *
         * @description Note that the creator username will not be set when
         * using the Mapillary API.
         *
         * @returns {string} Username of the creator who uploaded
         * the image.
         */
        get creatorUsername() {
            return this._spatial.creator.username;
        }
        /**
         * Get exifOrientation.
         *
         * @returns {number} EXIF orientation of original image.
         */
        get exifOrientation() {
            return this._spatial.exif_orientation;
        }
        /**
         * Get height.
         *
         * @returns {number} Height of original image, not adjusted
         * for orientation.
         */
        get height() {
            return this._spatial.height;
        }
        /**
         * Get image.
         *
         * @description The image will always be set on the current image.
         *
         * @returns {HTMLImageElement} Cached image element of the image.
         */
        get image() {
            return this._cache.image;
        }
        /**
         * Get image$.
         *
         * @returns {Observable<HTMLImageElement>} Observable emitting
         * the cached image when it is updated.
         *
         * @ignore
         */
        get image$() {
            return this._cache.image$;
        }
        /**
         * Get id.
         *
         * @returns {string} Globally unique id of the image.
         */
        get id() {
            return this._core.id;
        }
        /**
         * Get lngLat.
         *
         * @description If the SfM computed longitude, latitude exist
         * it will be returned, otherwise the original EXIF latitude
         * longitude.
         *
         * @returns {LngLat} Longitude, latitude in WGS84 datum,
         * measured in degrees.
         */
        get lngLat() {
            return this._core.computed_geometry != null ?
                this._core.computed_geometry :
                this._core.geometry;
        }
        /**
         * Get merged.
         *
         * @returns {boolean} Value indicating whether SfM has been
         * run on the image and the image has been merged into a
         * connected component.
         */
        get merged() {
            return this._spatial != null &&
                this._spatial.merge_id != null;
        }
        /**
         * Get mergeId.
         *
         * @description Will not be set if SfM has not yet been run on
         * image.
         *
         * @returns {stirng} Id of connected component to which image
         * belongs after the aligning merge.
         */
        get mergeId() {
            return this._spatial.merge_id;
        }
        /**
         * Get mesh.
         *
         * @description The mesh will always be set on the current image.
         *
         * @returns {MeshContract} SfM triangulated mesh of reconstructed
         * atomic 3D points.
         */
        get mesh() {
            return this._cache.mesh;
        }
        /**
         * Get originalAltitude.
         *
         * @returns {number} EXIF altitude, in meters, if available.
         */
        get originalAltitude() {
            return this._spatial.altitude;
        }
        /**
         * Get originalCompassAngle.
         *
         * @returns {number} Original EXIF compass angle, measured in
         * degrees.
         */
        get originalCompassAngle() {
            return this._spatial.compass_angle;
        }
        /**
         * Get originalLngLat.
         *
         * @returns {LngLat} Original EXIF longitude, latitude in
         * WGS84 datum, measured in degrees.
         */
        get originalLngLat() {
            return this._core.geometry;
        }
        /**
         * Get ownerId.
         *
         * @returns {string} Globally unique id of the owner to which
         * the image belongs. If the image does not belong to an
         * owner the owner id will be undefined.
         */
        get ownerId() {
            return !!this._spatial.owner ?
                this._spatial.owner.id :
                null;
        }
        /**
         * Get private.
         *
         * @returns {boolean} Value specifying if image is accessible to
         * organization members only or to everyone.
         */
        get private() {
            return this._spatial.private;
        }
        /**
         * Get qualityScore.
         *
         * @returns {number} A number between zero and one
         * determining the quality of the image. Blurriness
         * (motion blur / out-of-focus), occlusion (camera
         * mount, ego vehicle, water-drops), windshield
         * reflections, bad illumination (exposure, glare),
         * and bad weather condition (fog, rain, snow)
         * affect the quality score.
         *
         * @description Value should be on the interval [0, 1].
         */
        get qualityScore() {
            return this._spatial.quality_score;
        }
        /**
         * Get rotation.
         *
         * @description Will not be set if SfM has not been run.
         *
         * @returns {Array<number>} Rotation vector in angle axis representation.
         */
        get rotation() {
            return this._spatial.computed_rotation;
        }
        /**
         * Get scale.
         *
         * @description Will not be set if SfM has not been run.
         *
         * @returns {number} Scale of reconstruction the image
         * belongs to.
         */
        get scale() {
            return this._spatial.atomic_scale;
        }
        /**
         * Get sequenceId.
         *
         * @returns {string} Globally unique id of the sequence
         * to which the image belongs.
         */
        get sequenceId() {
            return !!this._core.sequence ?
                this._core.sequence.id :
                null;
        }
        /**
         * Get sequenceEdges.
         *
         * @returns {NavigationEdgeStatus} Value describing the status of the
         * sequence edges.
         *
         * @ignore
         */
        get sequenceEdges() {
            return this._cache.sequenceEdges;
        }
        /**
         * Get sequenceEdges$.
         *
         * @description Internal observable, should not be used as an API.
         *
         * @returns {Observable<NavigationEdgeStatus>} Observable emitting
         * values describing the status of the sequence edges.
         *
         * @ignore
         */
        get sequenceEdges$() {
            return this._cache.sequenceEdges$;
        }
        /**
         * Get spatialEdges.
         *
         * @returns {NavigationEdgeStatus} Value describing the status of the
         * spatial edges.
         *
         * @ignore
         */
        get spatialEdges() {
            return this._cache.spatialEdges;
        }
        /**
         * Get spatialEdges$.
         *
         * @description Internal observable, should not be used as an API.
         *
         * @returns {Observable<NavigationEdgeStatus>} Observable emitting
         * values describing the status of the spatial edges.
         *
         * @ignore
         */
        get spatialEdges$() {
            return this._cache.spatialEdges$;
        }
        /**
         * Get width.
         *
         * @returns {number} Width of original image, not
         * adjusted for orientation.
         */
        get width() {
            return this._spatial.width;
        }
        /**
         * Cache the image and mesh assets.
         *
         * @description The assets are always cached internally by the
         * library prior to setting a image as the current image.
         *
         * @returns {Observable<Image>} Observable emitting this image whenever the
         * load status has changed and when the mesh or image has been fully loaded.
         *
         * @ignore
         */
        cacheAssets$() {
            return this._cache
                .cacheAssets$(this._spatial, this.merged)
                .pipe(map(() => { return this; }));
        }
        /**
         * Cache the image asset.
         *
         * @description Use for caching a differently sized image than
         * the one currently held by the image.
         *
         * @returns {Observable<Image>} Observable emitting this image whenever the
         * load status has changed and when the mesh or image has been fully loaded.
         *
         * @ignore
         */
        cacheImage$() {
            return this._cache
                .cacheImage$(this._spatial)
                .pipe(map(() => { return this; }));
        }
        /**
         * Cache the sequence edges.
         *
         * @description The sequence edges are cached asynchronously
         * internally by the library.
         *
         * @param {Array<NavigationEdge>} edges - Sequence edges to cache.
         * @ignore
         */
        cacheSequenceEdges(edges) {
            this._cache.cacheSequenceEdges(edges);
        }
        /**
         * Cache the spatial edges.
         *
         * @description The spatial edges are cached asynchronously
         * internally by the library.
         *
         * @param {Array<NavigationEdge>} edges - Spatial edges to cache.
         * @ignore
         */
        cacheSpatialEdges(edges) {
            this._cache.cacheSpatialEdges(edges);
        }
        /**
         * Dispose the image.
         *
         * @description Disposes all cached assets.
         * @ignore
         */
        dispose() {
            if (this._cache != null) {
                this._cache.dispose();
                this._cache = null;
            }
            this._core = null;
            this._spatial = null;
        }
        /**
         * Initialize the image cache.
         *
         * @description The image cache is initialized internally by
         * the library.
         *
         * @param {ImageCache} cache - The image cache to set as cache.
         * @ignore
         */
        initializeCache(cache) {
            if (this._cache != null) {
                throw new Error(`Image cache already initialized (${this.id}).`);
            }
            this._cache = cache;
        }
        /**
         * Complete an image with spatial properties.
         *
         * @description The image is completed internally by
         * the library.
         *
         * @param {SpatialImageEnt} fill - The spatial image struct.
         * @ignore
         */
        makeComplete(fill) {
            if (fill == null) {
                throw new Error("Fill can not be null.");
            }
            this._spatial = fill;
        }
        /**
         * Reset the sequence edges.
         *
         * @ignore
         */
        resetSequenceEdges() {
            this._cache.resetSequenceEdges();
        }
        /**
         * Reset the spatial edges.
         *
         * @ignore
         */
        resetSpatialEdges() {
            this._cache.resetSpatialEdges();
        }
        /**
         * Clears the image and mesh assets, aborts
         * any outstanding requests and resets edges.
         *
         * @ignore
         */
        uncache() {
            if (this._cache == null) {
                return;
            }
            this._cache.dispose();
            this._cache = null;
        }
    }

    /**
     * @class ImageCache
     *
     * @classdesc Represents the cached properties of a image.
     */
    class ImageCache {
        /**
         * Create a new image cache instance.
         */
        constructor(provider) {
            this._disposed = false;
            this._provider = provider;
            this._image = null;
            this._mesh = null;
            this._sequenceEdges = { cached: false, edges: [] };
            this._spatialEdges = { cached: false, edges: [] };
            this._imageChanged$ = new Subject();
            this._image$ = this._imageChanged$.pipe(startWith(null), publishReplay(1), refCount());
            this._iamgeSubscription = this._image$.subscribe();
            this._sequenceEdgesChanged$ = new Subject();
            this._sequenceEdges$ = this._sequenceEdgesChanged$.pipe(startWith(this._sequenceEdges), publishReplay(1), refCount());
            this._sequenceEdgesSubscription = this._sequenceEdges$.subscribe(() => { });
            this._spatialEdgesChanged$ = new Subject();
            this._spatialEdges$ = this._spatialEdgesChanged$.pipe(startWith(this._spatialEdges), publishReplay(1), refCount());
            this._spatialEdgesSubscription = this._spatialEdges$.subscribe(() => { });
            this._cachingAssets$ = null;
        }
        /**
         * Get image.
         *
         * @description Will not be set when assets have not been cached
         * or when the object has been disposed.
         *
         * @returns {HTMLImageElement} Cached image element of the image.
         */
        get image() {
            return this._image;
        }
        /**
         * Get image$.
         *
         * @returns {Observable<HTMLImageElement>} Observable emitting
         * the cached image when it is updated.
         */
        get image$() {
            return this._image$;
        }
        /**
         * Get mesh.
         *
         * @description Will not be set when assets have not been cached
         * or when the object has been disposed.
         *
         * @returns {MeshContract} SfM triangulated mesh of reconstructed
         * atomic 3D points.
         */
        get mesh() {
            return this._mesh;
        }
        /**
         * Get sequenceEdges.
         *
         * @returns {NavigationEdgeStatus} Value describing the status of the
         * sequence edges.
         */
        get sequenceEdges() {
            return this._sequenceEdges;
        }
        /**
         * Get sequenceEdges$.
         *
         * @returns {Observable<NavigationEdgeStatus>} Observable emitting
         * values describing the status of the sequence edges.
         */
        get sequenceEdges$() {
            return this._sequenceEdges$;
        }
        /**
         * Get spatialEdges.
         *
         * @returns {NavigationEdgeStatus} Value describing the status of the
         * spatial edges.
         */
        get spatialEdges() {
            return this._spatialEdges;
        }
        /**
         * Get spatialEdges$.
         *
         * @returns {Observable<NavigationEdgeStatus>} Observable emitting
         * values describing the status of the spatial edges.
         */
        get spatialEdges$() {
            return this._spatialEdges$;
        }
        /**
         * Cache the image and mesh assets.
         *
         * @param {SpatialImageEnt} spatial - Spatial props of the image to cache.
         * @param {boolean} spherical - Value indicating whether image is a spherical.
         * @param {boolean} merged - Value indicating whether image is merged.
         * @returns {Observable<ImageCache>} Observable emitting this image
         * cache whenever the load status has changed and when the mesh or image
         * has been fully loaded.
         */
        cacheAssets$(spatial, merged) {
            if (this._cachingAssets$ != null) {
                return this._cachingAssets$;
            }
            this._cachingAssets$ = combineLatest(this._cacheImage$(spatial), this._cacheMesh$(spatial, merged)).pipe(map(([image, mesh]) => {
                this._image = image;
                this._mesh = mesh;
                return this;
            }), finalize(() => {
                this._cachingAssets$ = null;
            }), publishReplay(1), refCount());
            this._cachingAssets$.pipe(first((imageCache) => {
                return !!imageCache._image;
            }))
                .subscribe(() => {
                this._imageChanged$.next(this._image);
            }, () => { });
            return this._cachingAssets$;
        }
        /**
         * Cache an image with a higher resolution than the current one.
         *
         * @param {SpatialImageEnt} spatial - Spatial props.
         * @returns {Observable<ImageCache>} Observable emitting a single item,
         * the image cache, when the image has been cached. If supplied image
         * size is not larger than the current image size the image cache is
         * returned immediately.
         */
        cacheImage$(spatial) {
            if (this._image != null) {
                return of(this);
            }
            const cacheImage$ = this._cacheImage$(spatial)
                .pipe(first((image) => {
                return !!image;
            }), tap((image) => {
                this._disposeImage();
                this._image = image;
            }), map(() => {
                return this;
            }), publishReplay(1), refCount());
            cacheImage$
                .subscribe(() => {
                this._imageChanged$.next(this._image);
            }, () => { });
            return cacheImage$;
        }
        /**
         * Cache the sequence edges.
         *
         * @param {Array<NavigationEdge>} edges - Sequence edges to cache.
         */
        cacheSequenceEdges(edges) {
            this._sequenceEdges = { cached: true, edges: edges };
            this._sequenceEdgesChanged$.next(this._sequenceEdges);
        }
        /**
         * Cache the spatial edges.
         *
         * @param {Array<NavigationEdge>} edges - Spatial edges to cache.
         */
        cacheSpatialEdges(edges) {
            this._spatialEdges = { cached: true, edges: edges };
            this._spatialEdgesChanged$.next(this._spatialEdges);
        }
        /**
         * Dispose the image cache.
         *
         * @description Disposes all cached assets and unsubscribes to
         * all streams.
         */
        dispose() {
            this._iamgeSubscription.unsubscribe();
            this._sequenceEdgesSubscription.unsubscribe();
            this._spatialEdgesSubscription.unsubscribe();
            this._disposeImage();
            this._mesh = null;
            this._sequenceEdges = { cached: false, edges: [] };
            this._spatialEdges = { cached: false, edges: [] };
            this._imageChanged$.next(null);
            this._sequenceEdgesChanged$.next(this._sequenceEdges);
            this._spatialEdgesChanged$.next(this._spatialEdges);
            this._disposed = true;
            if (this._imageAborter != null) {
                this._imageAborter();
                this._imageAborter = null;
            }
            if (this._meshAborter != null) {
                this._meshAborter();
                this._meshAborter = null;
            }
        }
        /**
         * Reset the sequence edges.
         */
        resetSequenceEdges() {
            this._sequenceEdges = { cached: false, edges: [] };
            this._sequenceEdgesChanged$.next(this._sequenceEdges);
        }
        /**
         * Reset the spatial edges.
         */
        resetSpatialEdges() {
            this._spatialEdges = { cached: false, edges: [] };
            this._spatialEdgesChanged$.next(this._spatialEdges);
        }
        /**
         * Cache the image.
         *
         * @param {SpatialImageEnt} spatial - Spatial image.
         * @param {boolean} spherical - Value indicating whether image is a spherical.
         * @returns {Observable<ILoadStatusObject<HTMLImageElement>>} Observable
         * emitting a load status object every time the load status changes
         * and completes when the image is fully loaded.
         */
        _cacheImage$(spatial) {
            return Observable.create((subscriber) => {
                const abort = new Promise((_, reject) => {
                    this._imageAborter = reject;
                });
                const url = spatial.thumb.url;
                if (!url) {
                    const thumbId = spatial.thumb.id;
                    const message = `Incorrect thumb URL for ${spatial.id} ` +
                        `(${thumbId}, ${url})`;
                    subscriber.error(new Error(message));
                    return;
                }
                this._provider.getImageBuffer(url, abort)
                    .then((buffer) => {
                    this._imageAborter = null;
                    const image = new Image();
                    image.crossOrigin = "Anonymous";
                    image.onload = () => {
                        if (this._disposed) {
                            window.URL.revokeObjectURL(image.src);
                            const message = `Image load was aborted (${url})`;
                            subscriber.error(new Error(message));
                            return;
                        }
                        subscriber.next(image);
                        subscriber.complete();
                    };
                    image.onerror = () => {
                        this._imageAborter = null;
                        subscriber.error(new Error(`Failed to load image (${url})`));
                    };
                    const blob = new Blob([buffer]);
                    image.src = window.URL.createObjectURL(blob);
                }, (error) => {
                    this._imageAborter = null;
                    subscriber.error(error);
                });
            });
        }
        /**
         * Cache the mesh.
         *
         * @param {SpatialImageEnt} spatial - Spatial props.
         * @param {boolean} merged - Value indicating whether image is merged.
         * @returns {Observable<ILoadStatusObject<MeshContract>>} Observable emitting
         * a load status object every time the load status changes and completes
         * when the mesh is fully loaded.
         */
        _cacheMesh$(spatial, merged) {
            return Observable.create((subscriber) => {
                if (!merged) {
                    subscriber.next(this._createEmptyMesh());
                    subscriber.complete();
                    return;
                }
                const url = spatial.mesh.url;
                if (!url) {
                    const meshId = spatial.mesh.id;
                    const message = `Incorrect mesh URL for ${spatial.id} ` +
                        `(${meshId}, ${url})`;
                    console.warn(message);
                    subscriber.next(this._createEmptyMesh());
                    subscriber.complete();
                    return;
                }
                const abort = new Promise((_, reject) => {
                    this._meshAborter = reject;
                });
                this._provider.getMesh(url, abort)
                    .then((mesh) => {
                    this._meshAborter = null;
                    if (this._disposed) {
                        return;
                    }
                    subscriber.next(mesh);
                    subscriber.complete();
                }, (error) => {
                    this._meshAborter = null;
                    console.error(error);
                    subscriber.next(this._createEmptyMesh());
                    subscriber.complete();
                });
            });
        }
        /**
         * Create a load status object with an empty mesh.
         *
         * @returns {ILoadStatusObject<MeshContract>} Load status object
         * with empty mesh.
         */
        _createEmptyMesh() {
            return { faces: [], vertices: [] };
        }
        _disposeImage() {
            if (this._image != null) {
                window.URL.revokeObjectURL(this._image.src);
            }
            this._image = null;
        }
    }

    /**
     * @class Sequence
     *
     * @classdesc Represents a sequence of ordered images.
     */
    class Sequence {
        /**
         * Create a new sequene instance.
         *
         * @param {SequenceEnt} sequence - Raw sequence data.
         */
        constructor(sequence) {
            this._id = sequence.id;
            this._imageIds = sequence.image_ids;
        }
        /**
         * Get id.
         *
         * @returns {string} Unique sequence id.
         */
        get id() {
            return this._id;
        }
        /**
         * Get ids.
         *
         * @returns {Array<string>} Array of ordered image ids in the sequence.
         */
        get imageIds() {
            return this._imageIds;
        }
        /**
         * Dispose the sequence.
         *
         * @description Disposes all cached assets.
         */
        dispose() {
            this._id = null;
            this._imageIds = null;
        }
        /**
         * Find the next image id in the sequence with respect to
         * the provided image id.
         *
         * @param {string} id - Reference image id.
         * @returns {string} Next id in sequence if it exists, null otherwise.
         */
        findNext(id) {
            let i = this._imageIds.indexOf(id);
            if ((i + 1) >= this._imageIds.length || i === -1) {
                return null;
            }
            else {
                return this._imageIds[i + 1];
            }
        }
        /**
         * Find the previous image id in the sequence with respect to
         * the provided image id.
         *
         * @param {string} id - Reference image id.
         * @returns {string} Previous id in sequence if it exists, null otherwise.
         */
        findPrev(id) {
            let i = this._imageIds.indexOf(id);
            if (i === 0 || i === -1) {
                return null;
            }
            else {
                return this._imageIds[i - 1];
            }
        }
    }

    class EdgeCalculatorCoefficients {
        constructor() {
            this.sphericalPreferredDistance = 2;
            this.sphericalMotion = 2;
            this.sphericalSequencePenalty = 1;
            this.sphericalMergeCCPenalty = 4;
            this.stepPreferredDistance = 4;
            this.stepMotion = 3;
            this.stepRotation = 4;
            this.stepSequencePenalty = 2;
            this.stepMergeCCPenalty = 6;
            this.similarDistance = 2;
            this.similarRotation = 3;
            this.turnDistance = 4;
            this.turnMotion = 2;
            this.turnSequencePenalty = 1;
            this.turnMergeCCPenalty = 4;
        }
    }

    /**
     * Enumeration for edge directions
     * @enum {number}
     * @readonly
     * @description Directions for edges in image graph describing
     * sequence, spatial and image type relations between nodes.
     */
    exports.NavigationDirection = void 0;
    (function (NavigationDirection) {
        /**
         * Next image in the sequence.
         */
        NavigationDirection[NavigationDirection["Next"] = 0] = "Next";
        /**
         * Previous image in the sequence.
         */
        NavigationDirection[NavigationDirection["Prev"] = 1] = "Prev";
        /**
         * Step to the left keeping viewing direction.
         */
        NavigationDirection[NavigationDirection["StepLeft"] = 2] = "StepLeft";
        /**
         * Step to the right keeping viewing direction.
         */
        NavigationDirection[NavigationDirection["StepRight"] = 3] = "StepRight";
        /**
         * Step forward keeping viewing direction.
         */
        NavigationDirection[NavigationDirection["StepForward"] = 4] = "StepForward";
        /**
         * Step backward keeping viewing direction.
         */
        NavigationDirection[NavigationDirection["StepBackward"] = 5] = "StepBackward";
        /**
         * Turn 90 degrees counter clockwise.
         */
        NavigationDirection[NavigationDirection["TurnLeft"] = 6] = "TurnLeft";
        /**
         * Turn 90 degrees clockwise.
         */
        NavigationDirection[NavigationDirection["TurnRight"] = 7] = "TurnRight";
        /**
         * Turn 180 degrees.
         */
        NavigationDirection[NavigationDirection["TurnU"] = 8] = "TurnU";
        /**
         * Spherical in general direction.
         */
        NavigationDirection[NavigationDirection["Spherical"] = 9] = "Spherical";
        /**
         * Looking in roughly the same direction at rougly the same position.
         */
        NavigationDirection[NavigationDirection["Similar"] = 10] = "Similar";
    })(exports.NavigationDirection || (exports.NavigationDirection = {}));

    class EdgeCalculatorDirections {
        constructor() {
            this.steps = {};
            this.turns = {};
            this.spherical = {};
            this.steps[exports.NavigationDirection.StepForward] = {
                direction: exports.NavigationDirection.StepForward,
                motionChange: 0,
                useFallback: true,
            };
            this.steps[exports.NavigationDirection.StepBackward] = {
                direction: exports.NavigationDirection.StepBackward,
                motionChange: Math.PI,
                useFallback: true,
            };
            this.steps[exports.NavigationDirection.StepLeft] = {
                direction: exports.NavigationDirection.StepLeft,
                motionChange: Math.PI / 2,
                useFallback: false,
            };
            this.steps[exports.NavigationDirection.StepRight] = {
                direction: exports.NavigationDirection.StepRight,
                motionChange: -Math.PI / 2,
                useFallback: false,
            };
            this.turns[exports.NavigationDirection.TurnLeft] = {
                direction: exports.NavigationDirection.TurnLeft,
                directionChange: Math.PI / 2,
                motionChange: Math.PI / 4,
            };
            this.turns[exports.NavigationDirection.TurnRight] = {
                direction: exports.NavigationDirection.TurnRight,
                directionChange: -Math.PI / 2,
                motionChange: -Math.PI / 4,
            };
            this.turns[exports.NavigationDirection.TurnU] = {
                direction: exports.NavigationDirection.TurnU,
                directionChange: Math.PI,
                motionChange: null,
            };
            this.spherical[exports.NavigationDirection.StepForward] = {
                direction: exports.NavigationDirection.StepForward,
                directionChange: 0,
                next: exports.NavigationDirection.StepLeft,
                prev: exports.NavigationDirection.StepRight,
            };
            this.spherical[exports.NavigationDirection.StepBackward] = {
                direction: exports.NavigationDirection.StepBackward,
                directionChange: Math.PI,
                next: exports.NavigationDirection.StepRight,
                prev: exports.NavigationDirection.StepLeft,
            };
            this.spherical[exports.NavigationDirection.StepLeft] = {
                direction: exports.NavigationDirection.StepLeft,
                directionChange: Math.PI / 2,
                next: exports.NavigationDirection.StepBackward,
                prev: exports.NavigationDirection.StepForward,
            };
            this.spherical[exports.NavigationDirection.StepRight] = {
                direction: exports.NavigationDirection.StepRight,
                directionChange: -Math.PI / 2,
                next: exports.NavigationDirection.StepForward,
                prev: exports.NavigationDirection.StepBackward,
            };
        }
    }

    class EdgeCalculatorSettings {
        constructor() {
            this.sphericalMinDistance = 0.1;
            this.sphericalMaxDistance = 20;
            this.sphericalPreferredDistance = 5;
            this.sphericalMaxItems = 4;
            this.sphericalMaxStepTurnChange = Math.PI / 8;
            this.rotationMaxDistance = this.turnMaxRigDistance;
            this.rotationMaxDirectionChange = Math.PI / 6;
            this.rotationMaxVerticalDirectionChange = Math.PI / 8;
            this.similarMaxDirectionChange = Math.PI / 8;
            this.similarMaxDistance = 12;
            this.similarMinTimeDifference = 12 * 3600 * 1000;
            this.stepMaxDistance = 20;
            this.stepMaxDirectionChange = Math.PI / 6;
            this.stepMaxDrift = Math.PI / 6;
            this.stepPreferredDistance = 4;
            this.turnMaxDistance = 15;
            this.turnMaxDirectionChange = 2 * Math.PI / 9;
            this.turnMaxRigDistance = 0.65;
            this.turnMinRigDirectionChange = Math.PI / 6;
        }
        get maxDistance() {
            return Math.max(this.sphericalMaxDistance, this.similarMaxDistance, this.stepMaxDistance, this.turnMaxDistance);
        }
    }

    /**
     * @class MapillaryError
     *
     * @classdesc Generic Mapillary error.
     */
    class MapillaryError extends Error {
        constructor(message) {
            super(message);
            Object.setPrototypeOf(this, MapillaryError.prototype);
            this.name = "MapillaryError";
        }
    }

    class ArgumentMapillaryError extends MapillaryError {
        constructor(message) {
            super(message != null ? message : "The argument is not valid.");
            Object.setPrototypeOf(this, ArgumentMapillaryError.prototype);
            this.name = "ArgumentMapillaryError";
        }
    }

    /**
     * @class Spatial
     *
     * @classdesc Provides methods for scalar, vector and matrix calculations.
     */
    class Spatial {
        constructor() {
            this._epsilon = 1e-9;
        }
        /**
         * Converts azimuthal phi rotation (counter-clockwise with origin on X-axis) to
         * bearing (clockwise with origin at north or Y-axis).
         *
         * @param {number} phi - Azimuthal phi angle in radians.
         * @returns {number} Bearing in radians.
         */
        azimuthalToBearing(phi) {
            return -phi + Math.PI / 2;
        }
        /**
         * Converts degrees to radians.
         *
         * @param {number} deg - Degrees.
         * @returns {number} Radians.
         */
        degToRad(deg) {
            return Math.PI * deg / 180;
        }
        /**
         * Converts radians to degrees.
         *
         * @param {number} rad - Radians.
         * @returns {number} Degrees.
         */
        radToDeg(rad) {
            return 180 * rad / Math.PI;
        }
        /**
         * Creates a rotation matrix from an angle-axis vector.
         *
         * @param {Array<number>} angleAxis - Angle-axis representation of a rotation.
         * @returns {THREE.Matrix4} Rotation matrix.
         */
        rotationMatrix(angleAxis) {
            let axis = new Vector3(angleAxis[0], angleAxis[1], angleAxis[2]);
            let angle = axis.length();
            if (angle > 0) {
                axis.normalize();
            }
            return new Matrix4().makeRotationAxis(axis, angle);
        }
        /**
         * Rotates a vector according to a angle-axis rotation vector.
         *
         * @param {Array<number>} vector - Vector to rotate.
         * @param {Array<number>} angleAxis - Angle-axis representation of a rotation.
         * @returns {THREE.Vector3} Rotated vector.
         */
        rotate(vector, angleAxis) {
            let v = new Vector3(vector[0], vector[1], vector[2]);
            let rotationMatrix = this.rotationMatrix(angleAxis);
            v.applyMatrix4(rotationMatrix);
            return v;
        }
        /**
         * Calculates the optical center from a rotation vector
         * on the angle-axis representation and a translation vector
         * according to C = -R^T t.
         *
         * @param {Array<number>} rotation - Angle-axis representation of a rotation.
         * @param {Array<number>} translation - Translation vector.
         * @returns {THREE.Vector3} Optical center.
         */
        opticalCenter(rotation, translation) {
            let angleAxis = [-rotation[0], -rotation[1], -rotation[2]];
            let vector = [-translation[0], -translation[1], -translation[2]];
            return this.rotate(vector, angleAxis);
        }
        /**
         * Calculates the viewing direction from a rotation vector
         * on the angle-axis representation.
         *
         * @param {number[]} rotation - Angle-axis representation of a rotation.
         * @returns {THREE.Vector3} Viewing direction.
         */
        viewingDirection(rotation) {
            let angleAxis = [-rotation[0], -rotation[1], -rotation[2]];
            return this.rotate([0, 0, 1], angleAxis);
        }
        /**
         * Wrap a number on the interval [min, max].
         *
         * @param {number} value - Value to wrap.
         * @param {number} min - Lower endpoint of interval.
         * @param {number} max - Upper endpoint of interval.
         * @returns {number} The wrapped number.
         */
        wrap(value, min, max) {
            if (max < min) {
                throw new Error("Invalid arguments: max must be larger than min.");
            }
            let interval = (max - min);
            while (value > max || value < min) {
                if (value > max) {
                    value = value - interval;
                }
                else if (value < min) {
                    value = value + interval;
                }
            }
            return value;
        }
        /**
         * Wrap an angle on the interval [-Pi, Pi].
         *
         * @param {number} angle - Value to wrap.
         * @returns {number} Wrapped angle.
         */
        wrapAngle(angle) {
            return this.wrap(angle, -Math.PI, Math.PI);
        }
        /**
         * Limit the value to the interval [min, max] by changing the value to
         * the nearest available one when it is outside the interval.
         *
         * @param {number} value - Value to clamp.
         * @param {number} min - Minimum of the interval.
         * @param {number} max - Maximum of the interval.
         * @returns {number} Clamped value.
         */
        clamp(value, min, max) {
            if (value < min) {
                return min;
            }
            if (value > max) {
                return max;
            }
            return value;
        }
        /**
         * Calculates the counter-clockwise angle from the first
         * vector (x1, y1)^T to the second (x2, y2)^T.
         *
         * @param {number} x1 - X coordinate of first vector.
         * @param {number} y1 - Y coordinate of first vector.
         * @param {number} x2 - X coordinate of second vector.
         * @param {number} y2 - Y coordinate of second vector.
         * @returns {number} Counter clockwise angle between the vectors.
         */
        angleBetweenVector2(x1, y1, x2, y2) {
            let angle = Math.atan2(y2, x2) - Math.atan2(y1, x1);
            return this.wrapAngle(angle);
        }
        /**
         * Calculates the minimum (absolute) angle change for rotation
         * from one angle to another on the [-Pi, Pi] interval.
         *
         * @param {number} angle1 - Start angle.
         * @param {number} angle2 - Destination angle.
         * @returns {number} Absolute angle change between angles.
         */
        angleDifference(angle1, angle2) {
            let angle = angle2 - angle1;
            return this.wrapAngle(angle);
        }
        /**
         * Calculates the relative rotation angle between two
         * angle-axis vectors.
         *
         * @param {number} rotation1 - First angle-axis vector.
         * @param {number} rotation2 - Second angle-axis vector.
         * @returns {number} Relative rotation angle.
         */
        relativeRotationAngle(rotation1, rotation2) {
            let R1T = this.rotationMatrix([-rotation1[0], -rotation1[1], -rotation1[2]]);
            let R2 = this.rotationMatrix(rotation2);
            let R = R1T.multiply(R2);
            let elements = R.elements;
            // from Tr(R) = 1 + 2 * cos(theta)
            let tr = elements[0] + elements[5] + elements[10];
            let theta = Math.acos(Math.max(Math.min((tr - 1) / 2, 1), -1));
            return theta;
        }
        /**
         * Calculates the angle from a vector to a plane.
         *
         * @param {Array<number>} vector - The vector.
         * @param {Array<number>} planeNormal - Normal of the plane.
         * @returns {number} Angle from between plane and vector.
         */
        angleToPlane(vector, planeNormal) {
            let v = new Vector3().fromArray(vector);
            let norm = v.length();
            if (norm < this._epsilon) {
                return 0;
            }
            let projection = v.dot(new Vector3().fromArray(planeNormal));
            return Math.asin(projection / norm);
        }
        azimuthal(direction, up) {
            const directionVector = new Vector3().fromArray(direction);
            const upVector = new Vector3().fromArray(up);
            const upProjection = directionVector.clone().dot(upVector);
            const planeProjection = directionVector.clone().sub(upVector.clone().multiplyScalar(upProjection));
            return Math.atan2(planeProjection.y, planeProjection.x);
        }
        /**
         * Calculates the distance between two coordinates
         * (longitude, latitude pairs) in meters according to
         * the haversine formula.
         *
         * @param {number} lat1 - Latitude of the first coordinate in degrees.
         * @param {number} lng1 - Longitude of the first coordinate in degrees.
         * @param {number} lat2 - Latitude of the second coordinate in degrees.
         * @param {number} lng2 - Longitude of the second coordinate in degrees.
         * @returns {number} Distance between lat lon positions in meters.
         */
        distanceFromLngLat(lng1, lat1, lng2, lat2) {
            let r = 6371000;
            let dLat = this.degToRad(lat2 - lat1);
            let dLng = this.degToRad(lng2 - lng1);
            let hav = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                Math.cos(this.degToRad(lat1)) * Math.cos(this.degToRad(lat2)) *
                    Math.sin(dLng / 2) * Math.sin(dLng / 2);
            let d = 2 * r * Math.atan2(Math.sqrt(hav), Math.sqrt(1 - hav));
            return d;
        }
    }

    const spatial = new Spatial();
    function isSpherical(cameraType) {
        return cameraType === "spherical";
    }
    function isFisheye(cameraType) {
        return cameraType === "fisheye";
    }
    function computeTranslation(position, rotation, reference) {
        const C = geodeticToEnu(position.lng, position.lat, position.alt, reference.lng, reference.lat, reference.alt);
        const RC = spatial.rotate(C, rotation);
        const translation = [-RC.x, -RC.y, -RC.z];
        return translation;
    }
    function computeProjectedPoints(transform, basicVertices, basicDirections, pointsPerLine, viewportCoords) {
        const basicPoints = [];
        for (let side = 0; side < basicVertices.length; ++side) {
            const v = basicVertices[side];
            const d = basicDirections[side];
            for (let i = 0; i <= pointsPerLine; ++i) {
                basicPoints.push([v[0] + d[0] * i / pointsPerLine,
                    v[1] + d[1] * i / pointsPerLine]);
            }
        }
        const camera = new Camera$1();
        camera.up.copy(transform.upVector());
        camera.position.copy(new Vector3().fromArray(transform.unprojectSfM([0, 0], 0)));
        camera.lookAt(new Vector3().fromArray(transform.unprojectSfM([0, 0], 10)));
        camera.updateMatrix();
        camera.updateMatrixWorld(true);
        const projectedPoints = basicPoints
            .map((basicPoint) => {
            const worldPoint = transform.unprojectBasic(basicPoint, 10000);
            const cameraPoint = viewportCoords.worldToCamera(worldPoint, camera);
            return [
                Math.abs(cameraPoint[0] / cameraPoint[2]),
                Math.abs(cameraPoint[1] / cameraPoint[2]),
            ];
        });
        return projectedPoints;
    }

    /**
     * @class EdgeCalculator
     *
     * @classdesc Represents a class for calculating node edges.
     */
    class EdgeCalculator {
        /**
         * Create a new edge calculator instance.
         *
         * @param {EdgeCalculatorSettings} settings - Settings struct.
         * @param {EdgeCalculatorDirections} directions - Directions struct.
         * @param {EdgeCalculatorCoefficients} coefficients - Coefficients struct.
         */
        constructor(settings, directions, coefficients) {
            this._spatial = new Spatial();
            this._settings = settings != null ? settings : new EdgeCalculatorSettings();
            this._directions = directions != null ? directions : new EdgeCalculatorDirections();
            this._coefficients = coefficients != null ? coefficients : new EdgeCalculatorCoefficients();
        }
        /**
         * Returns the potential edges to destination nodes for a set
         * of nodes with respect to a source node.
         *
         * @param {Image} node - Source node.
         * @param {Array<Image>} nodes - Potential destination nodes.
         * @param {Array<string>} fallbackIds - Ids for destination nodes
         * that should be returned even if they do not meet the
         * criteria for a potential edge.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        getPotentialEdges(node, potentialImages, fallbackIds) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            if (!node.merged) {
                return [];
            }
            let currentDirection = this._spatial.viewingDirection(node.rotation);
            let currentVerticalDirection = this._spatial.angleToPlane(currentDirection.toArray(), [0, 0, 1]);
            let potentialEdges = [];
            for (let potential of potentialImages) {
                if (!potential.merged ||
                    potential.id === node.id) {
                    continue;
                }
                let enu = geodeticToEnu(potential.lngLat.lng, potential.lngLat.lat, potential.computedAltitude, node.lngLat.lng, node.lngLat.lat, node.computedAltitude);
                let motion = new Vector3(enu[0], enu[1], enu[2]);
                let distance = motion.length();
                if (distance > this._settings.maxDistance &&
                    fallbackIds.indexOf(potential.id) < 0) {
                    continue;
                }
                let motionChange = this._spatial.angleBetweenVector2(currentDirection.x, currentDirection.y, motion.x, motion.y);
                let verticalMotion = this._spatial.angleToPlane(motion.toArray(), [0, 0, 1]);
                let direction = this._spatial.viewingDirection(potential.rotation);
                let directionChange = this._spatial.angleBetweenVector2(currentDirection.x, currentDirection.y, direction.x, direction.y);
                let verticalDirection = this._spatial.angleToPlane(direction.toArray(), [0, 0, 1]);
                let verticalDirectionChange = verticalDirection - currentVerticalDirection;
                let rotation = this._spatial.relativeRotationAngle(node.rotation, potential.rotation);
                let worldMotionAzimuth = this._spatial.angleBetweenVector2(1, 0, motion.x, motion.y);
                let sameSequence = potential.sequenceId != null &&
                    node.sequenceId != null &&
                    potential.sequenceId === node.sequenceId;
                let sameMergeCC = potential.mergeId === node.mergeId;
                let sameUser = potential.creatorId === node.creatorId;
                let potentialEdge = {
                    capturedAt: potential.capturedAt,
                    directionChange: directionChange,
                    distance: distance,
                    spherical: isSpherical(potential.cameraType),
                    id: potential.id,
                    motionChange: motionChange,
                    rotation: rotation,
                    sameMergeCC: sameMergeCC,
                    sameSequence: sameSequence,
                    sameUser: sameUser,
                    sequenceId: potential.sequenceId,
                    verticalDirectionChange: verticalDirectionChange,
                    verticalMotion: verticalMotion,
                    worldMotionAzimuth: worldMotionAzimuth,
                };
                potentialEdges.push(potentialEdge);
            }
            return potentialEdges;
        }
        /**
         * Computes the sequence edges for a node.
         *
         * @param {Image} node - Source node.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        computeSequenceEdges(node, sequence) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            if (node.sequenceId !== sequence.id) {
                throw new ArgumentMapillaryError("Image and sequence does not correspond.");
            }
            let edges = [];
            let nextId = sequence.findNext(node.id);
            if (nextId != null) {
                edges.push({
                    data: {
                        direction: exports.NavigationDirection.Next,
                        worldMotionAzimuth: Number.NaN,
                    },
                    source: node.id,
                    target: nextId,
                });
            }
            let prevId = sequence.findPrev(node.id);
            if (prevId != null) {
                edges.push({
                    data: {
                        direction: exports.NavigationDirection.Prev,
                        worldMotionAzimuth: Number.NaN,
                    },
                    source: node.id,
                    target: prevId,
                });
            }
            return edges;
        }
        /**
         * Computes the similar edges for a node.
         *
         * @description Similar edges for perspective images
         * look roughly in the same direction and are positioned closed to the node.
         * Similar edges for spherical only target other spherical.
         *
         * @param {Image} node - Source node.
         * @param {Array<PotentialEdge>} potentialEdges - Potential edges.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        computeSimilarEdges(node, potentialEdges) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            let nodeSpherical = isSpherical(node.cameraType);
            let sequenceGroups = {};
            for (let potentialEdge of potentialEdges) {
                if (potentialEdge.sequenceId == null) {
                    continue;
                }
                if (potentialEdge.sameSequence) {
                    continue;
                }
                if (nodeSpherical) {
                    if (!potentialEdge.spherical) {
                        continue;
                    }
                }
                else {
                    if (!potentialEdge.spherical &&
                        Math.abs(potentialEdge.directionChange) > this._settings.similarMaxDirectionChange) {
                        continue;
                    }
                }
                if (potentialEdge.distance > this._settings.similarMaxDistance) {
                    continue;
                }
                if (potentialEdge.sameUser &&
                    Math.abs(potentialEdge.capturedAt - node.capturedAt) <
                        this._settings.similarMinTimeDifference) {
                    continue;
                }
                if (sequenceGroups[potentialEdge.sequenceId] == null) {
                    sequenceGroups[potentialEdge.sequenceId] = [];
                }
                sequenceGroups[potentialEdge.sequenceId].push(potentialEdge);
            }
            let similarEdges = [];
            let calculateScore = isSpherical(node.cameraType) ?
                (potentialEdge) => {
                    return potentialEdge.distance;
                } :
                (potentialEdge) => {
                    return this._coefficients.similarDistance * potentialEdge.distance +
                        this._coefficients.similarRotation * potentialEdge.rotation;
                };
            for (let sequenceId in sequenceGroups) {
                if (!sequenceGroups.hasOwnProperty(sequenceId)) {
                    continue;
                }
                let lowestScore = Number.MAX_VALUE;
                let similarEdge = null;
                for (let potentialEdge of sequenceGroups[sequenceId]) {
                    let score = calculateScore(potentialEdge);
                    if (score < lowestScore) {
                        lowestScore = score;
                        similarEdge = potentialEdge;
                    }
                }
                if (similarEdge == null) {
                    continue;
                }
                similarEdges.push(similarEdge);
            }
            return similarEdges
                .map((potentialEdge) => {
                return {
                    data: {
                        direction: exports.NavigationDirection.Similar,
                        worldMotionAzimuth: potentialEdge.worldMotionAzimuth,
                    },
                    source: node.id,
                    target: potentialEdge.id,
                };
            });
        }
        /**
         * Computes the step edges for a perspective node.
         *
         * @description Step edge targets can only be other perspective nodes.
         * Returns an empty array for spherical.
         *
         * @param {Image} node - Source node.
         * @param {Array<PotentialEdge>} potentialEdges - Potential edges.
         * @param {string} prevId - Id of previous node in sequence.
         * @param {string} nextId - Id of next node in sequence.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        computeStepEdges(node, potentialEdges, prevId, nextId) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            let edges = [];
            if (isSpherical(node.cameraType)) {
                return edges;
            }
            for (let k in this._directions.steps) {
                if (!this._directions.steps.hasOwnProperty(k)) {
                    continue;
                }
                let step = this._directions.steps[k];
                let lowestScore = Number.MAX_VALUE;
                let edge = null;
                let fallback = null;
                for (let potential of potentialEdges) {
                    if (potential.spherical) {
                        continue;
                    }
                    if (Math.abs(potential.directionChange) > this._settings.stepMaxDirectionChange) {
                        continue;
                    }
                    let motionDifference = this._spatial.angleDifference(step.motionChange, potential.motionChange);
                    let directionMotionDifference = this._spatial.angleDifference(potential.directionChange, motionDifference);
                    let drift = Math.max(Math.abs(motionDifference), Math.abs(directionMotionDifference));
                    if (Math.abs(drift) > this._settings.stepMaxDrift) {
                        continue;
                    }
                    let potentialId = potential.id;
                    if (step.useFallback && (potentialId === prevId || potentialId === nextId)) {
                        fallback = potential;
                    }
                    if (potential.distance > this._settings.stepMaxDistance) {
                        continue;
                    }
                    motionDifference = Math.sqrt(motionDifference * motionDifference +
                        potential.verticalMotion * potential.verticalMotion);
                    let score = this._coefficients.stepPreferredDistance *
                        Math.abs(potential.distance - this._settings.stepPreferredDistance) /
                        this._settings.stepMaxDistance +
                        this._coefficients.stepMotion * motionDifference / this._settings.stepMaxDrift +
                        this._coefficients.stepRotation * potential.rotation / this._settings.stepMaxDirectionChange +
                        this._coefficients.stepSequencePenalty * (potential.sameSequence ? 0 : 1) +
                        this._coefficients.stepMergeCCPenalty * (potential.sameMergeCC ? 0 : 1);
                    if (score < lowestScore) {
                        lowestScore = score;
                        edge = potential;
                    }
                }
                edge = edge == null ? fallback : edge;
                if (edge != null) {
                    edges.push({
                        data: {
                            direction: step.direction,
                            worldMotionAzimuth: edge.worldMotionAzimuth,
                        },
                        source: node.id,
                        target: edge.id,
                    });
                }
            }
            return edges;
        }
        /**
         * Computes the turn edges for a perspective node.
         *
         * @description Turn edge targets can only be other perspective images.
         * Returns an empty array for spherical.
         *
         * @param {Image} node - Source node.
         * @param {Array<PotentialEdge>} potentialEdges - Potential edges.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        computeTurnEdges(node, potentialEdges) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            let edges = [];
            if (isSpherical(node.cameraType)) {
                return edges;
            }
            for (let k in this._directions.turns) {
                if (!this._directions.turns.hasOwnProperty(k)) {
                    continue;
                }
                let turn = this._directions.turns[k];
                let lowestScore = Number.MAX_VALUE;
                let edge = null;
                for (let potential of potentialEdges) {
                    if (potential.spherical) {
                        continue;
                    }
                    if (potential.distance > this._settings.turnMaxDistance) {
                        continue;
                    }
                    let rig = turn.direction !== exports.NavigationDirection.TurnU &&
                        potential.distance < this._settings.turnMaxRigDistance &&
                        Math.abs(potential.directionChange) > this._settings.turnMinRigDirectionChange;
                    let directionDifference = this._spatial.angleDifference(turn.directionChange, potential.directionChange);
                    let score;
                    if (rig &&
                        potential.directionChange * turn.directionChange > 0 &&
                        Math.abs(potential.directionChange) < Math.abs(turn.directionChange)) {
                        score = -Math.PI / 2 + Math.abs(potential.directionChange);
                    }
                    else {
                        if (Math.abs(directionDifference) > this._settings.turnMaxDirectionChange) {
                            continue;
                        }
                        let motionDifference = turn.motionChange ?
                            this._spatial.angleDifference(turn.motionChange, potential.motionChange) : 0;
                        motionDifference = Math.sqrt(motionDifference * motionDifference +
                            potential.verticalMotion * potential.verticalMotion);
                        score =
                            this._coefficients.turnDistance * potential.distance /
                                this._settings.turnMaxDistance +
                                this._coefficients.turnMotion * motionDifference / Math.PI +
                                this._coefficients.turnSequencePenalty * (potential.sameSequence ? 0 : 1) +
                                this._coefficients.turnMergeCCPenalty * (potential.sameMergeCC ? 0 : 1);
                    }
                    if (score < lowestScore) {
                        lowestScore = score;
                        edge = potential;
                    }
                }
                if (edge != null) {
                    edges.push({
                        data: {
                            direction: turn.direction,
                            worldMotionAzimuth: edge.worldMotionAzimuth,
                        },
                        source: node.id,
                        target: edge.id,
                    });
                }
            }
            return edges;
        }
        /**
         * Computes the spherical edges for a perspective node.
         *
         * @description Perspective to spherical edge targets can only be
         * spherical nodes. Returns an empty array for spherical.
         *
         * @param {Image} node - Source node.
         * @param {Array<PotentialEdge>} potentialEdges - Potential edges.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        computePerspectiveToSphericalEdges(node, potentialEdges) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            if (isSpherical(node.cameraType)) {
                return [];
            }
            let lowestScore = Number.MAX_VALUE;
            let edge = null;
            for (let potential of potentialEdges) {
                if (!potential.spherical) {
                    continue;
                }
                let score = this._coefficients.sphericalPreferredDistance *
                    Math.abs(potential.distance - this._settings.sphericalPreferredDistance) /
                    this._settings.sphericalMaxDistance +
                    this._coefficients.sphericalMotion * Math.abs(potential.motionChange) / Math.PI +
                    this._coefficients.sphericalMergeCCPenalty * (potential.sameMergeCC ? 0 : 1);
                if (score < lowestScore) {
                    lowestScore = score;
                    edge = potential;
                }
            }
            if (edge == null) {
                return [];
            }
            return [
                {
                    data: {
                        direction: exports.NavigationDirection.Spherical,
                        worldMotionAzimuth: edge.worldMotionAzimuth,
                    },
                    source: node.id,
                    target: edge.id,
                },
            ];
        }
        /**
         * Computes the spherical and step edges for a spherical node.
         *
         * @description Spherical to spherical edge targets can only be
         * spherical nodes. spherical to step edge targets can only be perspective
         * nodes.
         *
         * @param {Image} node - Source node.
         * @param {Array<PotentialEdge>} potentialEdges - Potential edges.
         * @throws {ArgumentMapillaryError} If node is not full.
         */
        computeSphericalEdges(node, potentialEdges) {
            if (!node.complete) {
                throw new ArgumentMapillaryError("Image has to be full.");
            }
            if (!isSpherical(node.cameraType)) {
                return [];
            }
            let sphericalEdges = [];
            let potentialSpherical = [];
            let potentialSteps = [];
            for (let potential of potentialEdges) {
                if (potential.distance > this._settings.sphericalMaxDistance) {
                    continue;
                }
                if (potential.spherical) {
                    if (potential.distance < this._settings.sphericalMinDistance) {
                        continue;
                    }
                    potentialSpherical.push(potential);
                }
                else {
                    for (let k in this._directions.spherical) {
                        if (!this._directions.spherical.hasOwnProperty(k)) {
                            continue;
                        }
                        let spherical = this._directions.spherical[k];
                        let turn = this._spatial.angleDifference(potential.directionChange, potential.motionChange);
                        let turnChange = this._spatial.angleDifference(spherical.directionChange, turn);
                        if (Math.abs(turnChange) > this._settings.sphericalMaxStepTurnChange) {
                            continue;
                        }
                        potentialSteps.push([spherical.direction, potential]);
                        // break if step direction found
                        break;
                    }
                }
            }
            let maxRotationDifference = Math.PI / this._settings.sphericalMaxItems;
            let occupiedAngles = [];
            let stepAngles = [];
            for (let index = 0; index < this._settings.sphericalMaxItems; index++) {
                let rotation = index / this._settings.sphericalMaxItems * 2 * Math.PI;
                let lowestScore = Number.MAX_VALUE;
                let edge = null;
                for (let potential of potentialSpherical) {
                    let motionDifference = this._spatial.angleDifference(rotation, potential.motionChange);
                    if (Math.abs(motionDifference) > maxRotationDifference) {
                        continue;
                    }
                    let occupiedDifference = Number.MAX_VALUE;
                    for (let occupiedAngle of occupiedAngles) {
                        let difference = Math.abs(this._spatial.angleDifference(occupiedAngle, potential.motionChange));
                        if (difference < occupiedDifference) {
                            occupiedDifference = difference;
                        }
                    }
                    if (occupiedDifference <= maxRotationDifference) {
                        continue;
                    }
                    let score = this._coefficients.sphericalPreferredDistance *
                        Math.abs(potential.distance - this._settings.sphericalPreferredDistance) /
                        this._settings.sphericalMaxDistance +
                        this._coefficients.sphericalMotion * Math.abs(motionDifference) / maxRotationDifference +
                        this._coefficients.sphericalSequencePenalty * (potential.sameSequence ? 0 : 1) +
                        this._coefficients.sphericalMergeCCPenalty * (potential.sameMergeCC ? 0 : 1);
                    if (score < lowestScore) {
                        lowestScore = score;
                        edge = potential;
                    }
                }
                if (edge != null) {
                    occupiedAngles.push(edge.motionChange);
                    sphericalEdges.push({
                        data: {
                            direction: exports.NavigationDirection.Spherical,
                            worldMotionAzimuth: edge.worldMotionAzimuth,
                        },
                        source: node.id,
                        target: edge.id,
                    });
                }
                else {
                    stepAngles.push(rotation);
                }
            }
            let occupiedStepAngles = {};
            occupiedStepAngles[exports.NavigationDirection.Spherical] = occupiedAngles;
            occupiedStepAngles[exports.NavigationDirection.StepForward] = [];
            occupiedStepAngles[exports.NavigationDirection.StepLeft] = [];
            occupiedStepAngles[exports.NavigationDirection.StepBackward] = [];
            occupiedStepAngles[exports.NavigationDirection.StepRight] = [];
            for (let stepAngle of stepAngles) {
                let occupations = [];
                for (let k in this._directions.spherical) {
                    if (!this._directions.spherical.hasOwnProperty(k)) {
                        continue;
                    }
                    let spherical = this._directions.spherical[k];
                    let allOccupiedAngles = occupiedStepAngles[exports.NavigationDirection.Spherical]
                        .concat(occupiedStepAngles[spherical.direction])
                        .concat(occupiedStepAngles[spherical.prev])
                        .concat(occupiedStepAngles[spherical.next]);
                    let lowestScore = Number.MAX_VALUE;
                    let edge = null;
                    for (let potential of potentialSteps) {
                        if (potential[0] !== spherical.direction) {
                            continue;
                        }
                        let motionChange = this._spatial.angleDifference(stepAngle, potential[1].motionChange);
                        if (Math.abs(motionChange) > maxRotationDifference) {
                            continue;
                        }
                        let minOccupiedDifference = Number.MAX_VALUE;
                        for (let occupiedAngle of allOccupiedAngles) {
                            let occupiedDifference = Math.abs(this._spatial.angleDifference(occupiedAngle, potential[1].motionChange));
                            if (occupiedDifference < minOccupiedDifference) {
                                minOccupiedDifference = occupiedDifference;
                            }
                        }
                        if (minOccupiedDifference <= maxRotationDifference) {
                            continue;
                        }
                        let score = this._coefficients.sphericalPreferredDistance *
                            Math.abs(potential[1].distance - this._settings.sphericalPreferredDistance) /
                            this._settings.sphericalMaxDistance +
                            this._coefficients.sphericalMotion * Math.abs(motionChange) / maxRotationDifference +
                            this._coefficients.sphericalMergeCCPenalty * (potential[1].sameMergeCC ? 0 : 1);
                        if (score < lowestScore) {
                            lowestScore = score;
                            edge = potential;
                        }
                    }
                    if (edge != null) {
                        occupations.push(edge);
                        sphericalEdges.push({
                            data: {
                                direction: edge[0],
                                worldMotionAzimuth: edge[1].worldMotionAzimuth,
                            },
                            source: node.id,
                            target: edge[1].id,
                        });
                    }
                }
                for (let occupation of occupations) {
                    occupiedStepAngles[occupation[0]].push(occupation[1].motionChange);
                }
            }
            return sphericalEdges;
        }
    }

    class GraphMapillaryError extends MapillaryError {
        constructor(message) {
            super(message);
            Object.setPrototypeOf(this, GraphMapillaryError.prototype);
            this.name = "GraphMapillaryError";
        }
    }

    /**
     * @class Graph
     *
     * @classdesc Represents a graph of nodes with edges.
     */
    class Graph {
        /**
         * Create a new graph instance.
         *
         * @param {APIWrapper} [api] - API instance for retrieving data.
         * @param {rbush.RBush<NodeIndexItem>} [nodeIndex] - Node index for fast spatial retreival.
         * @param {GraphCalculator} [graphCalculator] - Instance for graph calculations.
         * @param {EdgeCalculator} [edgeCalculator] - Instance for edge calculations.
         * @param {FilterCreator} [filterCreator] - Instance for  filter creation.
         * @param {GraphConfiguration} [configuration] - Configuration struct.
         */
        constructor(api, nodeIndex, graphCalculator, edgeCalculator, filterCreator, configuration) {
            this._api = api;
            this._cachedNodes = {};
            this._cachedNodeTiles = {};
            this._cachedSequenceNodes = {};
            this._cachedSpatialEdges = {};
            this._cachedTiles = {};
            this._cachingFill$ = {};
            this._cachingFull$ = {};
            this._cachingSequenceNodes$ = {};
            this._cachingSequences$ = {};
            this._cachingSpatialArea$ = {};
            this._cachingTiles$ = {};
            this._changed$ = new Subject();
            this._filterCreator = filterCreator !== null && filterCreator !== void 0 ? filterCreator : new FilterCreator();
            this._filter = this._filterCreator.createFilter(undefined);
            this._filterSubject$ = new Subject();
            this._filter$ =
                concat(of(this._filter), this._filterSubject$).pipe(publishReplay(1), refCount());
            this._filterSubscription = this._filter$.subscribe(() => { });
            this._defaultAlt = 2;
            this._edgeCalculator = edgeCalculator !== null && edgeCalculator !== void 0 ? edgeCalculator : new EdgeCalculator();
            this._graphCalculator = graphCalculator !== null && graphCalculator !== void 0 ? graphCalculator : new GraphCalculator();
            this._configuration = configuration !== null && configuration !== void 0 ? configuration : {
                maxSequences: 50,
                maxUnusedImages: 100,
                maxUnusedPreStoredImages: 30,
                maxUnusedTiles: 20,
            };
            this._nodes = {};
            this._nodeIndex = nodeIndex !== null && nodeIndex !== void 0 ? nodeIndex : new Graph._spatialIndex(16);
            this._nodeIndexTiles = {};
            this._nodeToTile = {};
            this._preStored = {};
            this._requiredNodeTiles = {};
            this._requiredSpatialArea = {};
            this._sequences = {};
            this._tileThreshold = 20;
        }
        static register(spatialIndex) {
            Graph._spatialIndex = spatialIndex;
        }
        /**
         * Get api.
         *
         * @returns {APIWrapper} The API instance used by
         * the graph.
         */
        get api() {
            return this._api;
        }
        /**
         * Get changed$.
         *
         * @returns {Observable<Graph>} Observable emitting
         * the graph every time it has changed.
         */
        get changed$() {
            return this._changed$;
        }
        /**
         * Get filter$.
         *
         * @returns {Observable<FilterFunction>} Observable emitting
         * the filter every time it has changed.
         */
        get filter$() {
            return this._filter$;
        }
        /**
         * Caches the full node data for all images within a bounding
         * box.
         *
         * @description The node assets are not cached.
         *
         * @param {LngLat} sw - South west corner of bounding box.
         * @param {LngLat} ne - North east corner of bounding box.
         * @returns {Observable<Array<Image>>} Observable emitting
         * the full nodes in the bounding box.
         */
        cacheBoundingBox$(sw, ne) {
            const cacheTiles$ = this._api.data.geometry.bboxToCellIds(sw, ne)
                .filter((h) => {
                return !(h in this._cachedTiles);
            })
                .map((h) => {
                return h in this._cachingTiles$ ?
                    this._cachingTiles$[h] :
                    this._cacheTile$(h);
            });
            if (cacheTiles$.length === 0) {
                cacheTiles$.push(of(this));
            }
            return from(cacheTiles$).pipe(mergeAll(), last(), mergeMap(() => {
                const nodes = this._nodeIndex
                    .search({
                    maxX: ne.lng,
                    maxY: ne.lat,
                    minX: sw.lng,
                    minY: sw.lat,
                })
                    .map((item) => {
                    return item.node;
                });
                const fullNodes = [];
                const coreNodes = [];
                for (const node of nodes) {
                    if (node.complete) {
                        fullNodes.push(node);
                    }
                    else {
                        coreNodes.push(node.id);
                    }
                }
                const coreNodeBatches = [];
                const batchSize = 200;
                while (coreNodes.length > 0) {
                    coreNodeBatches.push(coreNodes.splice(0, batchSize));
                }
                const fullNodes$ = of(fullNodes);
                const fillNodes$ = coreNodeBatches
                    .map((batch) => {
                    return this._api
                        .getSpatialImages$(batch)
                        .pipe(map((items) => {
                        const result = [];
                        for (const item of items) {
                            const exists = this
                                .hasNode(item.node_id);
                            if (!exists) {
                                continue;
                            }
                            const node = this
                                .getNode(item.node_id);
                            if (!node.complete) {
                                this._makeFull(node, item.node);
                            }
                            result.push(node);
                        }
                        return result;
                    }));
                });
                return merge(fullNodes$, from(fillNodes$).pipe(mergeAll()));
            }), reduce((acc, value) => {
                return acc.concat(value);
            }));
        }
        /**
         * Caches the full node data for all images of a cell.
         *
         * @description The node assets are not cached.
         *
         * @param {string} cellId - Cell id.
         * @returns {Observable<Array<Image>>} Observable
         * emitting the full nodes of the cell.
         */
        cacheCell$(cellId) {
            const cacheCell$ = cellId in this._cachedTiles ?
                of(this) :
                cellId in this._cachingTiles$ ?
                    this._cachingTiles$[cellId] :
                    this._cacheTile$(cellId);
            return cacheCell$.pipe(mergeMap(() => {
                const cachedCell = this._cachedTiles[cellId];
                cachedCell.accessed = new Date().getTime();
                const cellNodes = cachedCell.nodes;
                const fullNodes = [];
                const coreNodes = [];
                for (const node of cellNodes) {
                    if (node.complete) {
                        fullNodes.push(node);
                    }
                    else {
                        coreNodes.push(node.id);
                    }
                }
                const coreNodeBatches = [];
                const batchSize = 200;
                while (coreNodes.length > 0) {
                    coreNodeBatches.push(coreNodes.splice(0, batchSize));
                }
                const fullNodes$ = of(fullNodes);
                const fillNodes$ = coreNodeBatches
                    .map((batch) => {
                    return this._api.getSpatialImages$(batch).pipe(map((items) => {
                        const filled = [];
                        for (const item of items) {
                            if (!item.node) {
                                console.warn(`Image is empty (${item.node})`);
                                continue;
                            }
                            const id = item.node_id;
                            if (!this.hasNode(id)) {
                                continue;
                            }
                            const node = this.getNode(id);
                            if (!node.complete) {
                                this._makeFull(node, item.node);
                            }
                            filled.push(node);
                        }
                        return filled;
                    }));
                });
                return merge(fullNodes$, from(fillNodes$).pipe(mergeAll()));
            }), reduce((acc, value) => {
                return acc.concat(value);
            }));
        }
        /**
         * Retrieve and cache node fill properties.
         *
         * @param {string} key - Key of node to fill.
         * @returns {Observable<Graph>} Observable emitting the graph
         * when the node has been updated.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheFill$(key) {
            if (key in this._cachingFull$) {
                throw new GraphMapillaryError(`Cannot fill node while caching full (${key}).`);
            }
            if (!this.hasNode(key)) {
                throw new GraphMapillaryError(`Cannot fill node that does not exist in graph (${key}).`);
            }
            if (key in this._cachingFill$) {
                return this._cachingFill$[key];
            }
            const node = this.getNode(key);
            if (node.complete) {
                throw new GraphMapillaryError(`Cannot fill node that is already full (${key}).`);
            }
            this._cachingFill$[key] = this._api.getSpatialImages$([key]).pipe(tap((items) => {
                for (const item of items) {
                    if (!item.node) {
                        console.warn(`Image is empty ${item.node_id}`);
                    }
                    if (!node.complete) {
                        this._makeFull(node, item.node);
                    }
                    delete this._cachingFill$[item.node_id];
                }
            }), map(() => { return this; }), finalize(() => {
                if (key in this._cachingFill$) {
                    delete this._cachingFill$[key];
                }
                this._changed$.next(this);
            }), publish(), refCount());
            return this._cachingFill$[key];
        }
        /**
         * Retrieve and cache full node properties.
         *
         * @param {string} key - Key of node to fill.
         * @returns {Observable<Graph>} Observable emitting the graph
         * when the node has been updated.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheFull$(key) {
            if (key in this._cachingFull$) {
                return this._cachingFull$[key];
            }
            if (this.hasNode(key)) {
                throw new GraphMapillaryError(`Cannot cache full node that already exist in graph (${key}).`);
            }
            this._cachingFull$[key] = this._api.getImages$([key]).pipe(tap((items) => {
                for (const item of items) {
                    if (!item.node) {
                        throw new GraphMapillaryError(`Image does not exist (${key}, ${item.node}).`);
                    }
                    const id = item.node_id;
                    if (this.hasNode(id)) {
                        const node = this.getNode(key);
                        if (!node.complete) {
                            this._makeFull(node, item.node);
                        }
                    }
                    else {
                        if (item.node.sequence.id == null) {
                            throw new GraphMapillaryError(`Image has no sequence key (${key}).`);
                        }
                        const node = new Image$1(item.node);
                        this._makeFull(node, item.node);
                        const cellId = this._api.data.geometry
                            .lngLatToCellId(node.originalLngLat);
                        this._preStore(cellId, node);
                        this._setNode(node);
                        delete this._cachingFull$[id];
                    }
                }
            }), map(() => this), finalize(() => {
                if (key in this._cachingFull$) {
                    delete this._cachingFull$[key];
                }
                this._changed$.next(this);
            }), publish(), refCount());
            return this._cachingFull$[key];
        }
        /**
         * Retrieve and cache a node sequence.
         *
         * @param {string} key - Key of node for which to retrieve sequence.
         * @returns {Observable<Graph>} Observable emitting the graph
         * when the sequence has been retrieved.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheNodeSequence$(key) {
            if (!this.hasNode(key)) {
                throw new GraphMapillaryError(`Cannot cache sequence edges of node that does not exist in graph (${key}).`);
            }
            let node = this.getNode(key);
            if (node.sequenceId in this._sequences) {
                throw new GraphMapillaryError(`Sequence already cached (${key}), (${node.sequenceId}).`);
            }
            return this._cacheSequence$(node.sequenceId);
        }
        /**
         * Retrieve and cache a sequence.
         *
         * @param {string} sequenceKey - Key of sequence to cache.
         * @returns {Observable<Graph>} Observable emitting the graph
         * when the sequence has been retrieved.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheSequence$(sequenceKey) {
            if (sequenceKey in this._sequences) {
                throw new GraphMapillaryError(`Sequence already cached (${sequenceKey})`);
            }
            return this._cacheSequence$(sequenceKey);
        }
        /**
         * Cache sequence edges for a node.
         *
         * @param {string} key - Key of node.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheSequenceEdges(key) {
            let node = this.getNode(key);
            if (!(node.sequenceId in this._sequences)) {
                throw new GraphMapillaryError(`Sequence is not cached (${key}), (${node.sequenceId})`);
            }
            let sequence = this._sequences[node.sequenceId].sequence;
            let edges = this._edgeCalculator.computeSequenceEdges(node, sequence);
            node.cacheSequenceEdges(edges);
        }
        /**
         * Retrieve and cache full nodes for all keys in a sequence.
         *
         * @param {string} sequenceKey - Key of sequence.
         * @param {string} referenceNodeKey - Key of node to use as reference
         * for optimized caching.
         * @returns {Observable<Graph>} Observable emitting the graph
         * when the nodes of the sequence has been cached.
         */
        cacheSequenceNodes$(sequenceKey, referenceNodeKey) {
            if (!this.hasSequence(sequenceKey)) {
                throw new GraphMapillaryError(`Cannot cache sequence nodes of sequence that does not exist in graph (${sequenceKey}).`);
            }
            if (this.hasSequenceNodes(sequenceKey)) {
                throw new GraphMapillaryError(`Sequence nodes already cached (${sequenceKey}).`);
            }
            const sequence = this.getSequence(sequenceKey);
            if (sequence.id in this._cachingSequenceNodes$) {
                return this._cachingSequenceNodes$[sequence.id];
            }
            const batches = [];
            const keys = sequence.imageIds.slice();
            const referenceBatchSize = 50;
            if (!!referenceNodeKey && keys.length > referenceBatchSize) {
                const referenceIndex = keys.indexOf(referenceNodeKey);
                const startIndex = Math.max(0, Math.min(referenceIndex - referenceBatchSize / 2, keys.length - referenceBatchSize));
                batches.push(keys.splice(startIndex, referenceBatchSize));
            }
            const batchSize = 200;
            while (keys.length > 0) {
                batches.push(keys.splice(0, batchSize));
            }
            let batchesToCache = batches.length;
            const sequenceNodes$ = from(batches).pipe(mergeMap((batch) => {
                return this._api.getImages$(batch).pipe(tap((items) => {
                    for (const item of items) {
                        if (!item.node) {
                            console.warn(`Image empty (${item.node_id})`);
                            continue;
                        }
                        const id = item.node_id;
                        if (this.hasNode(id)) {
                            const node = this.getNode(id);
                            if (!node.complete) {
                                this._makeFull(node, item.node);
                            }
                        }
                        else {
                            if (item.node.sequence.id == null) {
                                console.warn(`Sequence missing, discarding node (${item.node_id})`);
                            }
                            const node = new Image$1(item.node);
                            this._makeFull(node, item.node);
                            const cellId = this._api.data.geometry
                                .lngLatToCellId(node.originalLngLat);
                            this._preStore(cellId, node);
                            this._setNode(node);
                        }
                    }
                    batchesToCache--;
                }), map(() => this));
            }, 6), last(), finalize(() => {
                delete this._cachingSequenceNodes$[sequence.id];
                if (batchesToCache === 0) {
                    this._cachedSequenceNodes[sequence.id] = true;
                }
            }), publish(), refCount());
            this._cachingSequenceNodes$[sequence.id] = sequenceNodes$;
            return sequenceNodes$;
        }
        /**
         * Retrieve and cache full nodes for a node spatial area.
         *
         * @param {string} key - Key of node for which to retrieve sequence.
         * @returns {Observable<Graph>} Observable emitting the graph
         * when the nodes in the spatial area has been made full.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheSpatialArea$(key) {
            if (!this.hasNode(key)) {
                throw new GraphMapillaryError(`Cannot cache spatial area of node that does not exist in graph (${key}).`);
            }
            if (key in this._cachedSpatialEdges) {
                throw new GraphMapillaryError(`Image already spatially cached (${key}).`);
            }
            if (!(key in this._requiredSpatialArea)) {
                throw new GraphMapillaryError(`Spatial area not determined (${key}).`);
            }
            let spatialArea = this._requiredSpatialArea[key];
            if (Object.keys(spatialArea.cacheNodes).length === 0) {
                throw new GraphMapillaryError(`Spatial nodes already cached (${key}).`);
            }
            if (key in this._cachingSpatialArea$) {
                return this._cachingSpatialArea$[key];
            }
            let batches = [];
            while (spatialArea.cacheKeys.length > 0) {
                batches.push(spatialArea.cacheKeys.splice(0, 200));
            }
            let batchesToCache = batches.length;
            let spatialNodes$ = [];
            for (let batch of batches) {
                let spatialNodeBatch$ = this._api.getSpatialImages$(batch).pipe(tap((items) => {
                    for (const item of items) {
                        if (!item.node) {
                            console.warn(`Image is empty (${item.node_id})`);
                            continue;
                        }
                        const id = item.node_id;
                        const spatialNode = spatialArea.cacheNodes[id];
                        if (spatialNode.complete) {
                            delete spatialArea.cacheNodes[id];
                            continue;
                        }
                        this._makeFull(spatialNode, item.node);
                        delete spatialArea.cacheNodes[id];
                    }
                    if (--batchesToCache === 0) {
                        delete this._cachingSpatialArea$[key];
                    }
                }), map(() => { return this; }), catchError((error) => {
                    for (let batchKey of batch) {
                        if (batchKey in spatialArea.all) {
                            delete spatialArea.all[batchKey];
                        }
                        if (batchKey in spatialArea.cacheNodes) {
                            delete spatialArea.cacheNodes[batchKey];
                        }
                    }
                    if (--batchesToCache === 0) {
                        delete this._cachingSpatialArea$[key];
                    }
                    throw error;
                }), finalize(() => {
                    if (Object.keys(spatialArea.cacheNodes).length === 0) {
                        this._changed$.next(this);
                    }
                }), publish(), refCount());
                spatialNodes$.push(spatialNodeBatch$);
            }
            this._cachingSpatialArea$[key] = spatialNodes$;
            return spatialNodes$;
        }
        /**
         * Cache spatial edges for a node.
         *
         * @param {string} key - Key of node.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheSpatialEdges(key) {
            if (key in this._cachedSpatialEdges) {
                throw new GraphMapillaryError(`Spatial edges already cached (${key}).`);
            }
            let node = this.getNode(key);
            let sequence = this._sequences[node.sequenceId].sequence;
            let fallbackKeys = [];
            let prevKey = sequence.findPrev(node.id);
            if (prevKey != null) {
                fallbackKeys.push(prevKey);
            }
            let nextKey = sequence.findNext(node.id);
            if (nextKey != null) {
                fallbackKeys.push(nextKey);
            }
            let allSpatialNodes = this._requiredSpatialArea[key].all;
            let potentialNodes = [];
            let filter = this._filter;
            for (let spatialNodeKey in allSpatialNodes) {
                if (!allSpatialNodes.hasOwnProperty(spatialNodeKey)) {
                    continue;
                }
                let spatialNode = allSpatialNodes[spatialNodeKey];
                if (filter(spatialNode)) {
                    potentialNodes.push(spatialNode);
                }
            }
            let potentialEdges = this._edgeCalculator.getPotentialEdges(node, potentialNodes, fallbackKeys);
            let edges = this._edgeCalculator.computeStepEdges(node, potentialEdges, prevKey, nextKey);
            edges = edges.concat(this._edgeCalculator.computeTurnEdges(node, potentialEdges));
            edges = edges.concat(this._edgeCalculator.computeSphericalEdges(node, potentialEdges));
            edges = edges.concat(this._edgeCalculator.computePerspectiveToSphericalEdges(node, potentialEdges));
            edges = edges.concat(this._edgeCalculator.computeSimilarEdges(node, potentialEdges));
            node.cacheSpatialEdges(edges);
            this._cachedSpatialEdges[key] = node;
            delete this._requiredSpatialArea[key];
            delete this._cachedNodeTiles[key];
        }
        /**
         * Retrieve and cache tiles for a node.
         *
         * @param {string} key - Key of node for which to retrieve tiles.
         * @returns {Array<Observable<Graph>>} Array of observables emitting
         * the graph for each tile required for the node has been cached.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        cacheTiles$(key) {
            if (key in this._cachedNodeTiles) {
                throw new GraphMapillaryError(`Tiles already cached (${key}).`);
            }
            if (key in this._cachedSpatialEdges) {
                throw new GraphMapillaryError(`Spatial edges already cached so tiles considered cached (${key}).`);
            }
            if (!(key in this._requiredNodeTiles)) {
                throw new GraphMapillaryError(`Tiles have not been determined (${key}).`);
            }
            let nodeTiles = this._requiredNodeTiles[key];
            if (nodeTiles.cache.length === 0 &&
                nodeTiles.caching.length === 0) {
                throw new GraphMapillaryError(`Tiles already cached (${key}).`);
            }
            if (!this.hasNode(key)) {
                throw new GraphMapillaryError(`Cannot cache tiles of node that does not exist in graph (${key}).`);
            }
            let hs = nodeTiles.cache.slice();
            nodeTiles.caching = this._requiredNodeTiles[key].caching.concat(hs);
            nodeTiles.cache = [];
            let cacheTiles$ = [];
            for (let h of nodeTiles.caching) {
                const cacheTile$ = h in this._cachingTiles$ ?
                    this._cachingTiles$[h] :
                    this._cacheTile$(h);
                cacheTiles$.push(cacheTile$.pipe(tap((graph) => {
                    let index = nodeTiles.caching.indexOf(h);
                    if (index > -1) {
                        nodeTiles.caching.splice(index, 1);
                    }
                    if (nodeTiles.caching.length === 0 &&
                        nodeTiles.cache.length === 0) {
                        delete this._requiredNodeTiles[key];
                        this._cachedNodeTiles[key] = true;
                    }
                }), catchError((error) => {
                    let index = nodeTiles.caching.indexOf(h);
                    if (index > -1) {
                        nodeTiles.caching.splice(index, 1);
                    }
                    if (nodeTiles.caching.length === 0 &&
                        nodeTiles.cache.length === 0) {
                        delete this._requiredNodeTiles[key];
                        this._cachedNodeTiles[key] = true;
                    }
                    throw error;
                }), finalize(() => {
                    this._changed$.next(this);
                }), publish(), refCount()));
            }
            return cacheTiles$;
        }
        /**
         * Initialize the cache for a node.
         *
         * @param {string} key - Key of node.
         * @throws {GraphMapillaryError} When the operation is not valid on the
         * current graph.
         */
        initializeCache(key) {
            if (key in this._cachedNodes) {
                throw new GraphMapillaryError(`Image already in cache (${key}).`);
            }
            const node = this.getNode(key);
            const provider = this._api.data;
            node.initializeCache(new ImageCache(provider));
            const accessed = new Date().getTime();
            this._cachedNodes[key] = { accessed: accessed, node: node };
            this._updateCachedTileAccess(key, accessed);
        }
        /**
         * Get a value indicating if the graph is fill caching a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the node is being fill cached.
         */
        isCachingFill(key) {
            return key in this._cachingFill$;
        }
        /**
         * Get a value indicating if the graph is fully caching a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the node is being fully cached.
         */
        isCachingFull(key) {
            return key in this._cachingFull$;
        }
        /**
         * Get a value indicating if the graph is caching a sequence of a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the sequence of a node is
         * being cached.
         */
        isCachingNodeSequence(key) {
            let node = this.getNode(key);
            return node.sequenceId in this._cachingSequences$;
        }
        /**
         * Get a value indicating if the graph is caching a sequence.
         *
         * @param {string} sequenceKey - Key of sequence.
         * @returns {boolean} Value indicating if the sequence is
         * being cached.
         */
        isCachingSequence(sequenceKey) {
            return sequenceKey in this._cachingSequences$;
        }
        /**
         * Get a value indicating if the graph is caching sequence nodes.
         *
         * @param {string} sequenceKey - Key of sequence.
         * @returns {boolean} Value indicating if the sequence nodes are
         * being cached.
         */
        isCachingSequenceNodes(sequenceKey) {
            return sequenceKey in this._cachingSequenceNodes$;
        }
        /**
         * Get a value indicating if the graph is caching the tiles
         * required for calculating spatial edges of a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the tiles of
         * a node are being cached.
         */
        isCachingTiles(key) {
            return key in this._requiredNodeTiles &&
                this._requiredNodeTiles[key].cache.length === 0 &&
                this._requiredNodeTiles[key].caching.length > 0;
        }
        /**
         * Get a value indicating if the cache has been initialized
         * for a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the cache has been
         * initialized for a node.
         */
        hasInitializedCache(key) {
            return key in this._cachedNodes;
        }
        /**
         * Get a value indicating if a node exist in the graph.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if a node exist in the graph.
         */
        hasNode(key) {
            let accessed = new Date().getTime();
            this._updateCachedNodeAccess(key, accessed);
            this._updateCachedTileAccess(key, accessed);
            return key in this._nodes;
        }
        /**
         * Get a value indicating if a node sequence exist in the graph.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if a node sequence exist
         * in the graph.
         */
        hasNodeSequence(key) {
            let node = this.getNode(key);
            let sequenceKey = node.sequenceId;
            let hasNodeSequence = sequenceKey in this._sequences;
            if (hasNodeSequence) {
                this._sequences[sequenceKey].accessed = new Date().getTime();
            }
            return hasNodeSequence;
        }
        /**
         * Get a value indicating if a sequence exist in the graph.
         *
         * @param {string} sequenceKey - Key of sequence.
         * @returns {boolean} Value indicating if a sequence exist
         * in the graph.
         */
        hasSequence(sequenceKey) {
            let hasSequence = sequenceKey in this._sequences;
            if (hasSequence) {
                this._sequences[sequenceKey].accessed = new Date().getTime();
            }
            return hasSequence;
        }
        /**
         * Get a value indicating if sequence nodes has been cached in the graph.
         *
         * @param {string} sequenceKey - Key of sequence.
         * @returns {boolean} Value indicating if a sequence nodes has been
         * cached in the graph.
         */
        hasSequenceNodes(sequenceKey) {
            return sequenceKey in this._cachedSequenceNodes;
        }
        /**
         * Get a value indicating if the graph has fully cached
         * all nodes in the spatial area of a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the spatial area
         * of a node has been cached.
         */
        hasSpatialArea(key) {
            if (!this.hasNode(key)) {
                throw new GraphMapillaryError(`Spatial area nodes cannot be determined if node not in graph (${key}).`);
            }
            if (key in this._cachedSpatialEdges) {
                return true;
            }
            if (key in this._requiredSpatialArea) {
                return Object
                    .keys(this._requiredSpatialArea[key].cacheNodes)
                    .length === 0;
            }
            let node = this.getNode(key);
            let bbox = this._graphCalculator
                .boundingBoxCorners(node.lngLat, this._tileThreshold);
            let spatialItems = this._nodeIndex
                .search({
                maxX: bbox[1].lng,
                maxY: bbox[1].lat,
                minX: bbox[0].lng,
                minY: bbox[0].lat,
            });
            let spatialNodes = {
                all: {},
                cacheKeys: [],
                cacheNodes: {},
            };
            for (let spatialItem of spatialItems) {
                spatialNodes.all[spatialItem.node.id] = spatialItem.node;
                if (!spatialItem.node.complete) {
                    spatialNodes.cacheKeys.push(spatialItem.node.id);
                    spatialNodes.cacheNodes[spatialItem.node.id] = spatialItem.node;
                }
            }
            this._requiredSpatialArea[key] = spatialNodes;
            return spatialNodes.cacheKeys.length === 0;
        }
        /**
         * Get a value indicating if the graph has a tiles required
         * for a node.
         *
         * @param {string} key - Key of node.
         * @returns {boolean} Value indicating if the the tiles required
         * by a node has been cached.
         */
        hasTiles(key) {
            if (key in this._cachedNodeTiles) {
                return true;
            }
            if (key in this._cachedSpatialEdges) {
                return true;
            }
            if (!this.hasNode(key)) {
                throw new GraphMapillaryError(`Image does not exist in graph (${key}).`);
            }
            let nodeTiles = { cache: [], caching: [] };
            if (!(key in this._requiredNodeTiles)) {
                const node = this.getNode(key);
                const [sw, ne] = this._graphCalculator
                    .boundingBoxCorners(node.lngLat, this._tileThreshold);
                nodeTiles.cache = this._api.data.geometry
                    .bboxToCellIds(sw, ne)
                    .filter((h) => {
                    return !(h in this._cachedTiles);
                });
                if (nodeTiles.cache.length > 0) {
                    this._requiredNodeTiles[key] = nodeTiles;
                }
            }
            else {
                nodeTiles = this._requiredNodeTiles[key];
            }
            return nodeTiles.cache.length === 0 && nodeTiles.caching.length === 0;
        }
        /**
         * Get a node.
         *
         * @param {string} key - Key of node.
         * @returns {Image} Retrieved node.
         */
        getNode(key) {
            let accessed = new Date().getTime();
            this._updateCachedNodeAccess(key, accessed);
            this._updateCachedTileAccess(key, accessed);
            return this._nodes[key];
        }
        /**
         * Get a sequence.
         *
         * @param {string} sequenceKey - Key of sequence.
         * @returns {Image} Retrieved sequence.
         */
        getSequence(sequenceKey) {
            let sequenceAccess = this._sequences[sequenceKey];
            sequenceAccess.accessed = new Date().getTime();
            return sequenceAccess.sequence;
        }
        /**
         * Reset all spatial edges of the graph nodes.
         */
        resetSpatialEdges() {
            let cachedKeys = Object.keys(this._cachedSpatialEdges);
            for (let cachedKey of cachedKeys) {
                let node = this._cachedSpatialEdges[cachedKey];
                node.resetSpatialEdges();
                delete this._cachedSpatialEdges[cachedKey];
            }
        }
        /**
         * Reset the complete graph but keep the nodes corresponding
         * to the supplied keys. All other nodes will be disposed.
         *
         * @param {Array<string>} keepKeys - Keys for nodes to keep
         * in graph after reset.
         */
        reset(keepKeys) {
            const nodes = [];
            for (const key of keepKeys) {
                if (!this.hasNode(key)) {
                    throw new Error(`Image does not exist ${key}`);
                }
                const node = this.getNode(key);
                node.resetSequenceEdges();
                node.resetSpatialEdges();
                nodes.push(node);
            }
            for (let cachedKey of Object.keys(this._cachedNodes)) {
                if (keepKeys.indexOf(cachedKey) !== -1) {
                    continue;
                }
                this._cachedNodes[cachedKey].node.dispose();
                delete this._cachedNodes[cachedKey];
            }
            this._cachedNodeTiles = {};
            this._cachedSpatialEdges = {};
            this._cachedTiles = {};
            this._cachingFill$ = {};
            this._cachingFull$ = {};
            this._cachingSequences$ = {};
            this._cachingSpatialArea$ = {};
            this._cachingTiles$ = {};
            this._nodes = {};
            this._nodeToTile = {};
            this._preStored = {};
            for (const node of nodes) {
                this._nodes[node.id] = node;
                const h = this._api.data.geometry.lngLatToCellId(node.originalLngLat);
                this._preStore(h, node);
            }
            this._requiredNodeTiles = {};
            this._requiredSpatialArea = {};
            this._sequences = {};
            this._nodeIndexTiles = {};
            this._nodeIndex.clear();
        }
        /**
         * Set the spatial node filter.
         *
         * @emits FilterFunction The filter function to the {@link Graph.filter$}
         * observable.
         *
         * @param {FilterExpression} filter - Filter expression to be applied
         * when calculating spatial edges.
         */
        setFilter(filter) {
            this._filter = this._filterCreator.createFilter(filter);
            this._filterSubject$.next(this._filter);
        }
        /**
         * Uncache the graph according to the graph configuration.
         *
         * @description Uncaches unused tiles, unused nodes and
         * sequences according to the numbers specified in the
         * graph configuration. Sequences does not have a direct
         * reference to either tiles or nodes and may be uncached
         * even if they are related to the nodes that should be kept.
         *
         * @param {Array<string>} keepIds - Ids of nodes to keep in
         * graph unrelated to last access. Tiles related to those keys
         * will also be kept in graph.
         * @param {Array<string>} keepCellIds - Ids of cells to keep in
         * graph unrelated to last access. The nodes of the cells may
         * still be uncached if not specified in the keep ids param
         * but are guaranteed to not be disposed.
         * @param {string} keepSequenceId - Optional id of sequence
         * for which the belonging nodes should not be disposed or
         * removed from the graph. These nodes may still be uncached if
         * not specified in keep ids param but are guaranteed to not
         * be disposed.
         */
        uncache(keepIds, keepCellIds, keepSequenceId) {
            const idsInUse = {};
            this._addNewKeys(idsInUse, this._cachingFull$);
            this._addNewKeys(idsInUse, this._cachingFill$);
            this._addNewKeys(idsInUse, this._cachingSpatialArea$);
            this._addNewKeys(idsInUse, this._requiredNodeTiles);
            this._addNewKeys(idsInUse, this._requiredSpatialArea);
            for (const key of keepIds) {
                if (key in idsInUse) {
                    continue;
                }
                idsInUse[key] = true;
            }
            const tileThreshold = this._tileThreshold;
            const calculator = this._graphCalculator;
            const geometry = this._api.data.geometry;
            const keepCells = new Set(keepCellIds);
            for (let id in idsInUse) {
                if (!idsInUse.hasOwnProperty(id)) {
                    continue;
                }
                const node = this._nodes[id];
                const [sw, ne] = calculator
                    .boundingBoxCorners(node.lngLat, tileThreshold);
                const nodeCellIds = geometry.bboxToCellIds(sw, ne);
                for (const nodeCellId of nodeCellIds) {
                    if (!keepCells.has(nodeCellId)) {
                        keepCells.add(nodeCellId);
                    }
                }
            }
            const potentialCells = [];
            for (let cellId in this._cachedTiles) {
                if (!this._cachedTiles.hasOwnProperty(cellId) ||
                    keepCells.has(cellId)) {
                    continue;
                }
                potentialCells.push([cellId, this._cachedTiles[cellId]]);
            }
            const uncacheCells = potentialCells
                .sort((h1, h2) => {
                return h2[1].accessed - h1[1].accessed;
            })
                .slice(this._configuration.maxUnusedTiles)
                .map((h) => {
                return h[0];
            });
            for (let uncacheCell of uncacheCells) {
                this._uncacheTile(uncacheCell, keepSequenceId);
            }
            const potentialPreStored = [];
            const nonCachedPreStored = [];
            for (let cellId in this._preStored) {
                if (!this._preStored.hasOwnProperty(cellId) ||
                    cellId in this._cachingTiles$) {
                    continue;
                }
                const prestoredNodes = this._preStored[cellId];
                for (let id in prestoredNodes) {
                    if (!prestoredNodes.hasOwnProperty(id) || id in idsInUse) {
                        continue;
                    }
                    if (prestoredNodes[id].sequenceId === keepSequenceId) {
                        continue;
                    }
                    if (id in this._cachedNodes) {
                        potentialPreStored.push([this._cachedNodes[id], cellId]);
                    }
                    else {
                        nonCachedPreStored.push([id, cellId]);
                    }
                }
            }
            const uncachePreStored = potentialPreStored
                .sort(([na1], [na2]) => {
                return na2.accessed - na1.accessed;
            })
                .slice(this._configuration.maxUnusedPreStoredImages)
                .map(([na, h]) => {
                return [na.node.id, h];
            });
            this._uncachePreStored(nonCachedPreStored);
            this._uncachePreStored(uncachePreStored);
            const potentialNodes = [];
            for (let id in this._cachedNodes) {
                if (!this._cachedNodes.hasOwnProperty(id) || id in idsInUse) {
                    continue;
                }
                potentialNodes.push(this._cachedNodes[id]);
            }
            const uncacheNodes = potentialNodes
                .sort((n1, n2) => {
                return n2.accessed - n1.accessed;
            })
                .slice(this._configuration.maxUnusedImages);
            for (const nodeAccess of uncacheNodes) {
                nodeAccess.node.uncache();
                const id = nodeAccess.node.id;
                delete this._cachedNodes[id];
                if (id in this._cachedNodeTiles) {
                    delete this._cachedNodeTiles[id];
                }
                if (id in this._cachedSpatialEdges) {
                    delete this._cachedSpatialEdges[id];
                }
            }
            const potentialSequences = [];
            for (let sequenceId in this._sequences) {
                if (!this._sequences.hasOwnProperty(sequenceId) ||
                    sequenceId in this._cachingSequences$ ||
                    sequenceId === keepSequenceId) {
                    continue;
                }
                potentialSequences.push(this._sequences[sequenceId]);
            }
            const uncacheSequences = potentialSequences
                .sort((s1, s2) => {
                return s2.accessed - s1.accessed;
            })
                .slice(this._configuration.maxSequences);
            for (const sequenceAccess of uncacheSequences) {
                const sequenceId = sequenceAccess.sequence.id;
                delete this._sequences[sequenceId];
                if (sequenceId in this._cachedSequenceNodes) {
                    delete this._cachedSequenceNodes[sequenceId];
                }
                sequenceAccess.sequence.dispose();
            }
        }
        /**
         * Updates existing cells with new core nodes.
         *
         * @description Non-existing cells are discarded
         * and not requested at all.
         *
         * Existing nodes are not changed.
         *
         * New nodes are not made full or getting assets
         * cached.
         *
         * @param {Array<string>} cellIds - Cell ids.
         * @returns {Observable<Array<Image>>} Observable
         * emitting the updated cells.
         */
        updateCells$(cellIds) {
            const cachedCells = this._cachedTiles;
            const cachingCells = this._cachingTiles$;
            return from(cellIds)
                .pipe(mergeMap((cellId) => {
                if (cellId in cachedCells) {
                    return this._updateCell$(cellId);
                }
                if (cellId in cachingCells) {
                    return cachingCells[cellId]
                        .pipe(catchError(() => {
                        return of(this);
                    }), mergeMap(() => this._updateCell$(cellId)));
                }
                return empty();
            }));
        }
        /**
         * Unsubscribes all subscriptions.
         *
         * @description Afterwards, you must not call any other methods
         * on the graph instance.
         */
        unsubscribe() {
            this._filterSubscription.unsubscribe();
        }
        _addNewKeys(keys, dict) {
            for (let key in dict) {
                if (!dict.hasOwnProperty(key) || !this.hasNode(key)) {
                    continue;
                }
                if (!(key in keys)) {
                    keys[key] = true;
                }
            }
        }
        _cacheSequence$(sequenceId) {
            if (sequenceId in this._cachingSequences$) {
                return this._cachingSequences$[sequenceId];
            }
            this._cachingSequences$[sequenceId] = this._api
                .getSequence$(sequenceId)
                .pipe(tap((sequence) => {
                if (!sequence) {
                    console.warn(`Sequence does not exist ` +
                        `(${sequenceId})`);
                }
                else {
                    if (!(sequence.id in this._sequences)) {
                        this._sequences[sequence.id] = {
                            accessed: new Date().getTime(),
                            sequence: new Sequence(sequence),
                        };
                    }
                    delete this._cachingSequences$[sequenceId];
                }
            }), map(() => { return this; }), finalize(() => {
                if (sequenceId in this._cachingSequences$) {
                    delete this._cachingSequences$[sequenceId];
                }
                this._changed$.next(this);
            }), publish(), refCount());
            return this._cachingSequences$[sequenceId];
        }
        _cacheTile$(cellId) {
            this._cachingTiles$[cellId] = this._api
                .getCoreImages$(cellId)
                .pipe(tap((contract) => {
                if (cellId in this._cachedTiles) {
                    return;
                }
                const cores = contract.images;
                this._nodeIndexTiles[cellId] = [];
                this._cachedTiles[cellId] = {
                    accessed: new Date().getTime(),
                    nodes: [],
                };
                const hCache = this._cachedTiles[cellId].nodes;
                const preStored = this._removeFromPreStore(cellId);
                for (const core of cores) {
                    if (!core) {
                        break;
                    }
                    if (core.sequence.id == null) {
                        console.warn(`Sequence missing, discarding ` +
                            `node (${core.id})`);
                        continue;
                    }
                    if (preStored != null && core.id in preStored) {
                        const preStoredNode = preStored[core.id];
                        delete preStored[core.id];
                        hCache.push(preStoredNode);
                        const preStoredNodeIndexItem = {
                            lat: preStoredNode.lngLat.lat,
                            lng: preStoredNode.lngLat.lng,
                            node: preStoredNode,
                        };
                        this._nodeIndex.insert(preStoredNodeIndexItem);
                        this._nodeIndexTiles[cellId]
                            .push(preStoredNodeIndexItem);
                        this._nodeToTile[preStoredNode.id] = cellId;
                        continue;
                    }
                    const node = new Image$1(core);
                    hCache.push(node);
                    const nodeIndexItem = {
                        lat: node.lngLat.lat,
                        lng: node.lngLat.lng,
                        node: node,
                    };
                    this._nodeIndex.insert(nodeIndexItem);
                    this._nodeIndexTiles[cellId].push(nodeIndexItem);
                    this._nodeToTile[node.id] = cellId;
                    this._setNode(node);
                }
                delete this._cachingTiles$[cellId];
            }), map(() => this), catchError((error) => {
                delete this._cachingTiles$[cellId];
                throw error;
            }), publish(), refCount());
            return this._cachingTiles$[cellId];
        }
        _makeFull(node, fillNode) {
            if (fillNode.computed_altitude == null) {
                fillNode.computed_altitude = this._defaultAlt;
            }
            if (fillNode.computed_rotation == null) {
                fillNode.computed_rotation = this._graphCalculator.rotationFromCompass(fillNode.compass_angle, fillNode.exif_orientation);
            }
            node.makeComplete(fillNode);
        }
        _preStore(h, node) {
            if (!(h in this._preStored)) {
                this._preStored[h] = {};
            }
            this._preStored[h][node.id] = node;
        }
        _removeFromPreStore(h) {
            let preStored = null;
            if (h in this._preStored) {
                preStored = this._preStored[h];
                delete this._preStored[h];
            }
            return preStored;
        }
        _setNode(node) {
            let key = node.id;
            if (this.hasNode(key)) {
                throw new GraphMapillaryError(`Image already exist (${key}).`);
            }
            this._nodes[key] = node;
        }
        _uncacheTile(h, keepSequenceKey) {
            for (let node of this._cachedTiles[h].nodes) {
                let key = node.id;
                delete this._nodeToTile[key];
                if (key in this._cachedNodes) {
                    delete this._cachedNodes[key];
                }
                if (key in this._cachedNodeTiles) {
                    delete this._cachedNodeTiles[key];
                }
                if (key in this._cachedSpatialEdges) {
                    delete this._cachedSpatialEdges[key];
                }
                if (node.sequenceId === keepSequenceKey) {
                    this._preStore(h, node);
                    node.uncache();
                }
                else {
                    delete this._nodes[key];
                    if (node.sequenceId in this._cachedSequenceNodes) {
                        delete this._cachedSequenceNodes[node.sequenceId];
                    }
                    node.dispose();
                }
            }
            for (let nodeIndexItem of this._nodeIndexTiles[h]) {
                this._nodeIndex.remove(nodeIndexItem);
            }
            delete this._nodeIndexTiles[h];
            delete this._cachedTiles[h];
        }
        _uncachePreStored(preStored) {
            let hs = {};
            for (let [key, h] of preStored) {
                if (key in this._nodes) {
                    delete this._nodes[key];
                }
                if (key in this._cachedNodes) {
                    delete this._cachedNodes[key];
                }
                let node = this._preStored[h][key];
                if (node.sequenceId in this._cachedSequenceNodes) {
                    delete this._cachedSequenceNodes[node.sequenceId];
                }
                delete this._preStored[h][key];
                node.dispose();
                hs[h] = true;
            }
            for (let h in hs) {
                if (!hs.hasOwnProperty(h)) {
                    continue;
                }
                if (Object.keys(this._preStored[h]).length === 0) {
                    delete this._preStored[h];
                }
            }
        }
        _updateCachedTileAccess(key, accessed) {
            if (key in this._nodeToTile) {
                this._cachedTiles[this._nodeToTile[key]].accessed = accessed;
            }
        }
        _updateCachedNodeAccess(key, accessed) {
            if (key in this._cachedNodes) {
                this._cachedNodes[key].accessed = accessed;
            }
        }
        _updateCell$(cellId) {
            return this._api.getCoreImages$(cellId).pipe(mergeMap((contract) => {
                if (!(cellId in this._cachedTiles)) {
                    return empty();
                }
                const nodeIndex = this._nodeIndex;
                const nodeIndexCell = this._nodeIndexTiles[cellId];
                const nodeToCell = this._nodeToTile;
                const cell = this._cachedTiles[cellId];
                cell.accessed = new Date().getTime();
                const cellNodes = cell.nodes;
                const cores = contract.images;
                for (const core of cores) {
                    if (core == null) {
                        break;
                    }
                    if (this.hasNode(core.id)) {
                        continue;
                    }
                    if (core.sequence.id == null) {
                        console.warn(`Sequence missing, discarding ` +
                            `node (${core.id})`);
                        continue;
                    }
                    const node = new Image$1(core);
                    cellNodes.push(node);
                    const nodeIndexItem = {
                        lat: node.lngLat.lat,
                        lng: node.lngLat.lng,
                        node: node,
                    };
                    nodeIndex.insert(nodeIndexItem);
                    nodeIndexCell.push(nodeIndexItem);
                    nodeToCell[node.id] = cellId;
                    this._setNode(node);
                }
                return of(cellId);
            }), catchError((error) => {
                console.error(error);
                return empty();
            }));
        }
    }

    class MarkerSet {
        constructor() {
            this._hash = {};
            this._index = new MarkerSet._spatialIndex(16);
            this._indexChanged$ = new Subject();
            this._updated$ = new Subject();
        }
        static register(spatialIndex) {
            MarkerSet._spatialIndex = spatialIndex;
        }
        get changed$() {
            return this._indexChanged$;
        }
        get updated$() {
            return this._updated$;
        }
        add(markers) {
            const updated = [];
            const hash = this._hash;
            const index = this._index;
            for (const marker of markers) {
                const id = marker.id;
                if (id in hash) {
                    index.remove(hash[id]);
                    updated.push(marker);
                }
                const item = {
                    lat: marker.lngLat.lat,
                    lng: marker.lngLat.lng,
                    marker: marker,
                };
                hash[id] = item;
                index.insert(item);
            }
            if (updated.length > 0) {
                this._updated$.next(updated);
            }
            if (markers.length > updated.length) {
                this._indexChanged$.next(this);
            }
        }
        has(id) {
            return id in this._hash;
        }
        get(id) {
            return this.has(id) ? this._hash[id].marker : undefined;
        }
        getAll() {
            return this._index
                .all()
                .map((indexItem) => {
                return indexItem.marker;
            });
        }
        remove(ids) {
            const hash = this._hash;
            const index = this._index;
            let changed = false;
            for (const id of ids) {
                if (!(id in hash)) {
                    continue;
                }
                const item = hash[id];
                index.remove(item);
                delete hash[id];
                changed = true;
            }
            if (changed) {
                this._indexChanged$.next(this);
            }
        }
        removeAll() {
            this._hash = {};
            this._index.clear();
            this._indexChanged$.next(this);
        }
        search([sw, ne]) {
            return this._index
                .search({
                maxX: ne.lng,
                maxY: ne.lat,
                minX: sw.lng,
                minY: sw.lat,
            })
                .map((indexItem) => {
                return indexItem.marker;
            });
        }
        update(marker) {
            const hash = this._hash;
            const index = this._index;
            const id = marker.id;
            if (!(id in hash)) {
                return;
            }
            index.remove(hash[id]);
            const item = {
                lat: marker.lngLat.lat,
                lng: marker.lngLat.lng,
                marker: marker,
            };
            hash[id] = item;
            index.insert(item);
        }
    }

    function quickselect(arr, k, left, right, compare) {
        quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare$2);
    }

    function quickselectStep(arr, k, left, right, compare) {

        while (right > left) {
            if (right - left > 600) {
                var n = right - left + 1;
                var m = k - left + 1;
                var z = Math.log(n);
                var s = 0.5 * Math.exp(2 * z / 3);
                var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
                var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
                var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
                quickselectStep(arr, k, newLeft, newRight, compare);
            }

            var t = arr[k];
            var i = left;
            var j = right;

            swap(arr, left, k);
            if (compare(arr[right], t) > 0) swap(arr, left, right);

            while (i < j) {
                swap(arr, i, j);
                i++;
                j--;
                while (compare(arr[i], t) < 0) i++;
                while (compare(arr[j], t) > 0) j--;
            }

            if (compare(arr[left], t) === 0) swap(arr, left, j);
            else {
                j++;
                swap(arr, j, right);
            }

            if (j <= k) left = j + 1;
            if (k <= j) right = j - 1;
        }
    }

    function swap(arr, i, j) {
        var tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    function defaultCompare$2(a, b) {
        return a < b ? -1 : a > b ? 1 : 0;
    }

    class RBush {
        constructor(maxEntries = 9) {
            // max entries in a node is 9 by default; min node fill is 40% for best performance
            this._maxEntries = Math.max(4, maxEntries);
            this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
            this.clear();
        }

        all() {
            return this._all(this.data, []);
        }

        search(bbox) {
            let node = this.data;
            const result = [];

            if (!intersects$1(bbox, node)) return result;

            const toBBox = this.toBBox;
            const nodesToSearch = [];

            while (node) {
                for (let i = 0; i < node.children.length; i++) {
                    const child = node.children[i];
                    const childBBox = node.leaf ? toBBox(child) : child;

                    if (intersects$1(bbox, childBBox)) {
                        if (node.leaf) result.push(child);
                        else if (contains(bbox, childBBox)) this._all(child, result);
                        else nodesToSearch.push(child);
                    }
                }
                node = nodesToSearch.pop();
            }

            return result;
        }

        collides(bbox) {
            let node = this.data;

            if (!intersects$1(bbox, node)) return false;

            const nodesToSearch = [];
            while (node) {
                for (let i = 0; i < node.children.length; i++) {
                    const child = node.children[i];
                    const childBBox = node.leaf ? this.toBBox(child) : child;

                    if (intersects$1(bbox, childBBox)) {
                        if (node.leaf || contains(bbox, childBBox)) return true;
                        nodesToSearch.push(child);
                    }
                }
                node = nodesToSearch.pop();
            }

            return false;
        }

        load(data) {
            if (!(data && data.length)) return this;

            if (data.length < this._minEntries) {
                for (let i = 0; i < data.length; i++) {
                    this.insert(data[i]);
                }
                return this;
            }

            // recursively build the tree with the given data from scratch using OMT algorithm
            let node = this._build(data.slice(), 0, data.length - 1, 0);

            if (!this.data.children.length) {
                // save as is if tree is empty
                this.data = node;

            } else if (this.data.height === node.height) {
                // split root if trees have the same height
                this._splitRoot(this.data, node);

            } else {
                if (this.data.height < node.height) {
                    // swap trees if inserted one is bigger
                    const tmpNode = this.data;
                    this.data = node;
                    node = tmpNode;
                }

                // insert the small tree into the large tree at appropriate level
                this._insert(node, this.data.height - node.height - 1, true);
            }

            return this;
        }

        insert(item) {
            if (item) this._insert(item, this.data.height - 1);
            return this;
        }

        clear() {
            this.data = createNode([]);
            return this;
        }

        remove(item, equalsFn) {
            if (!item) return this;

            let node = this.data;
            const bbox = this.toBBox(item);
            const path = [];
            const indexes = [];
            let i, parent, goingUp;

            // depth-first iterative tree traversal
            while (node || path.length) {

                if (!node) { // go up
                    node = path.pop();
                    parent = path[path.length - 1];
                    i = indexes.pop();
                    goingUp = true;
                }

                if (node.leaf) { // check current node
                    const index = findItem(item, node.children, equalsFn);

                    if (index !== -1) {
                        // item found, remove the item and condense tree upwards
                        node.children.splice(index, 1);
                        path.push(node);
                        this._condense(path);
                        return this;
                    }
                }

                if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
                    path.push(node);
                    indexes.push(i);
                    i = 0;
                    parent = node;
                    node = node.children[0];

                } else if (parent) { // go right
                    i++;
                    node = parent.children[i];
                    goingUp = false;

                } else node = null; // nothing found
            }

            return this;
        }

        toBBox(item) { return item; }

        compareMinX(a, b) { return a.minX - b.minX; }
        compareMinY(a, b) { return a.minY - b.minY; }

        toJSON() { return this.data; }

        fromJSON(data) {
            this.data = data;
            return this;
        }

        _all(node, result) {
            const nodesToSearch = [];
            while (node) {
                if (node.leaf) result.push(...node.children);
                else nodesToSearch.push(...node.children);

                node = nodesToSearch.pop();
            }
            return result;
        }

        _build(items, left, right, height) {

            const N = right - left + 1;
            let M = this._maxEntries;
            let node;

            if (N <= M) {
                // reached leaf level; return leaf
                node = createNode(items.slice(left, right + 1));
                calcBBox(node, this.toBBox);
                return node;
            }

            if (!height) {
                // target height of the bulk-loaded tree
                height = Math.ceil(Math.log(N) / Math.log(M));

                // target number of root entries to maximize storage utilization
                M = Math.ceil(N / Math.pow(M, height - 1));
            }

            node = createNode([]);
            node.leaf = false;
            node.height = height;

            // split the items into M mostly square tiles

            const N2 = Math.ceil(N / M);
            const N1 = N2 * Math.ceil(Math.sqrt(M));

            multiSelect(items, left, right, N1, this.compareMinX);

            for (let i = left; i <= right; i += N1) {

                const right2 = Math.min(i + N1 - 1, right);

                multiSelect(items, i, right2, N2, this.compareMinY);

                for (let j = i; j <= right2; j += N2) {

                    const right3 = Math.min(j + N2 - 1, right2);

                    // pack each entry recursively
                    node.children.push(this._build(items, j, right3, height - 1));
                }
            }

            calcBBox(node, this.toBBox);

            return node;
        }

        _chooseSubtree(bbox, node, level, path) {
            while (true) {
                path.push(node);

                if (node.leaf || path.length - 1 === level) break;

                let minArea = Infinity;
                let minEnlargement = Infinity;
                let targetNode;

                for (let i = 0; i < node.children.length; i++) {
                    const child = node.children[i];
                    const area = bboxArea(child);
                    const enlargement = enlargedArea(bbox, child) - area;

                    // choose entry with the least area enlargement
                    if (enlargement < minEnlargement) {
                        minEnlargement = enlargement;
                        minArea = area < minArea ? area : minArea;
                        targetNode = child;

                    } else if (enlargement === minEnlargement) {
                        // otherwise choose one with the smallest area
                        if (area < minArea) {
                            minArea = area;
                            targetNode = child;
                        }
                    }
                }

                node = targetNode || node.children[0];
            }

            return node;
        }

        _insert(item, level, isNode) {
            const bbox = isNode ? item : this.toBBox(item);
            const insertPath = [];

            // find the best node for accommodating the item, saving all nodes along the path too
            const node = this._chooseSubtree(bbox, this.data, level, insertPath);

            // put the item into the node
            node.children.push(item);
            extend(node, bbox);

            // split on node overflow; propagate upwards if necessary
            while (level >= 0) {
                if (insertPath[level].children.length > this._maxEntries) {
                    this._split(insertPath, level);
                    level--;
                } else break;
            }

            // adjust bboxes along the insertion path
            this._adjustParentBBoxes(bbox, insertPath, level);
        }

        // split overflowed node into two
        _split(insertPath, level) {
            const node = insertPath[level];
            const M = node.children.length;
            const m = this._minEntries;

            this._chooseSplitAxis(node, m, M);

            const splitIndex = this._chooseSplitIndex(node, m, M);

            const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
            newNode.height = node.height;
            newNode.leaf = node.leaf;

            calcBBox(node, this.toBBox);
            calcBBox(newNode, this.toBBox);

            if (level) insertPath[level - 1].children.push(newNode);
            else this._splitRoot(node, newNode);
        }

        _splitRoot(node, newNode) {
            // split root node
            this.data = createNode([node, newNode]);
            this.data.height = node.height + 1;
            this.data.leaf = false;
            calcBBox(this.data, this.toBBox);
        }

        _chooseSplitIndex(node, m, M) {
            let index;
            let minOverlap = Infinity;
            let minArea = Infinity;

            for (let i = m; i <= M - m; i++) {
                const bbox1 = distBBox(node, 0, i, this.toBBox);
                const bbox2 = distBBox(node, i, M, this.toBBox);

                const overlap = intersectionArea(bbox1, bbox2);
                const area = bboxArea(bbox1) + bboxArea(bbox2);

                // choose distribution with minimum overlap
                if (overlap < minOverlap) {
                    minOverlap = overlap;
                    index = i;

                    minArea = area < minArea ? area : minArea;

                } else if (overlap === minOverlap) {
                    // otherwise choose distribution with minimum area
                    if (area < minArea) {
                        minArea = area;
                        index = i;
                    }
                }
            }

            return index || M - m;
        }

        // sorts node children by the best axis for split
        _chooseSplitAxis(node, m, M) {
            const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
            const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
            const xMargin = this._allDistMargin(node, m, M, compareMinX);
            const yMargin = this._allDistMargin(node, m, M, compareMinY);

            // if total distributions margin value is minimal for x, sort by minX,
            // otherwise it's already sorted by minY
            if (xMargin < yMargin) node.children.sort(compareMinX);
        }

        // total margin of all possible split distributions where each node is at least m full
        _allDistMargin(node, m, M, compare) {
            node.children.sort(compare);

            const toBBox = this.toBBox;
            const leftBBox = distBBox(node, 0, m, toBBox);
            const rightBBox = distBBox(node, M - m, M, toBBox);
            let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);

            for (let i = m; i < M - m; i++) {
                const child = node.children[i];
                extend(leftBBox, node.leaf ? toBBox(child) : child);
                margin += bboxMargin(leftBBox);
            }

            for (let i = M - m - 1; i >= m; i--) {
                const child = node.children[i];
                extend(rightBBox, node.leaf ? toBBox(child) : child);
                margin += bboxMargin(rightBBox);
            }

            return margin;
        }

        _adjustParentBBoxes(bbox, path, level) {
            // adjust bboxes along the given tree path
            for (let i = level; i >= 0; i--) {
                extend(path[i], bbox);
            }
        }

        _condense(path) {
            // go through the path, removing empty nodes and updating bboxes
            for (let i = path.length - 1, siblings; i >= 0; i--) {
                if (path[i].children.length === 0) {
                    if (i > 0) {
                        siblings = path[i - 1].children;
                        siblings.splice(siblings.indexOf(path[i]), 1);

                    } else this.clear();

                } else calcBBox(path[i], this.toBBox);
            }
        }
    }

    function findItem(item, items, equalsFn) {
        if (!equalsFn) return items.indexOf(item);

        for (let i = 0; i < items.length; i++) {
            if (equalsFn(item, items[i])) return i;
        }
        return -1;
    }

    // calculate node's bbox from bboxes of its children
    function calcBBox(node, toBBox) {
        distBBox(node, 0, node.children.length, toBBox, node);
    }

    // min bounding rectangle of node children from k to p-1
    function distBBox(node, k, p, toBBox, destNode) {
        if (!destNode) destNode = createNode(null);
        destNode.minX = Infinity;
        destNode.minY = Infinity;
        destNode.maxX = -Infinity;
        destNode.maxY = -Infinity;

        for (let i = k; i < p; i++) {
            const child = node.children[i];
            extend(destNode, node.leaf ? toBBox(child) : child);
        }

        return destNode;
    }

    function extend(a, b) {
        a.minX = Math.min(a.minX, b.minX);
        a.minY = Math.min(a.minY, b.minY);
        a.maxX = Math.max(a.maxX, b.maxX);
        a.maxY = Math.max(a.maxY, b.maxY);
        return a;
    }

    function compareNodeMinX(a, b) { return a.minX - b.minX; }
    function compareNodeMinY(a, b) { return a.minY - b.minY; }

    function bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }
    function bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }

    function enlargedArea(a, b) {
        return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *
               (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
    }

    function intersectionArea(a, b) {
        const minX = Math.max(a.minX, b.minX);
        const minY = Math.max(a.minY, b.minY);
        const maxX = Math.min(a.maxX, b.maxX);
        const maxY = Math.min(a.maxY, b.maxY);

        return Math.max(0, maxX - minX) *
               Math.max(0, maxY - minY);
    }

    function contains(a, b) {
        return a.minX <= b.minX &&
               a.minY <= b.minY &&
               b.maxX <= a.maxX &&
               b.maxY <= a.maxY;
    }

    function intersects$1(a, b) {
        return b.minX <= a.maxX &&
               b.minY <= a.maxY &&
               b.maxX >= a.minX &&
               b.maxY >= a.minY;
    }

    function createNode(children) {
        return {
            children,
            height: 1,
            leaf: true,
            minX: Infinity,
            minY: Infinity,
            maxX: -Infinity,
            maxY: -Infinity
        };
    }

    // sort an array so that items come in groups of n unsorted items, with groups sorted between each other;
    // combines selection algorithm with binary divide & conquer approach

    function multiSelect(arr, left, right, n, compare) {
        const stack = [left, right];

        while (stack.length) {
            right = stack.pop();
            left = stack.pop();

            if (right - left <= n) continue;

            const mid = left + Math.ceil((right - left) / n / 2) * n;
            quickselect(arr, mid, left, right, compare);

            stack.push(left, mid, mid, right);
        }
    }

    class GeoRBush extends RBush {
        compareMinX(a, b) {
            return a.lng - b.lng;
        }
        compareMinY(a, b) {
            return a.lat - b.lat;
        }
        toBBox(item) {
            return {
                minX: item.lng,
                minY: item.lat,
                maxX: item.lng,
                maxY: item.lat,
            };
        }
    }

    /*
     * Copyright (C) 2008 Apple Inc. All Rights Reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions
     * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     *
     * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
     * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
     * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     *
     * Ported from Webkit
     * http://svn.webkit.org/repository/webkit/trunk/Source/WebCore/platform/graphics/UnitBezier.h
     */
    var unitbezier = UnitBezier;

    function UnitBezier(p1x, p1y, p2x, p2y) {
        // Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
        this.cx = 3.0 * p1x;
        this.bx = 3.0 * (p2x - p1x) - this.cx;
        this.ax = 1.0 - this.cx - this.bx;

        this.cy = 3.0 * p1y;
        this.by = 3.0 * (p2y - p1y) - this.cy;
        this.ay = 1.0 - this.cy - this.by;

        this.p1x = p1x;
        this.p1y = p2y;
        this.p2x = p2x;
        this.p2y = p2y;
    }

    UnitBezier.prototype.sampleCurveX = function(t) {
        // `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
        return ((this.ax * t + this.bx) * t + this.cx) * t;
    };

    UnitBezier.prototype.sampleCurveY = function(t) {
        return ((this.ay * t + this.by) * t + this.cy) * t;
    };

    UnitBezier.prototype.sampleCurveDerivativeX = function(t) {
        return (3.0 * this.ax * t + 2.0 * this.bx) * t + this.cx;
    };

    UnitBezier.prototype.solveCurveX = function(x, epsilon) {
        if (typeof epsilon === 'undefined') epsilon = 1e-6;

        var t0, t1, t2, x2, i;

        // First try a few iterations of Newton's method -- normally very fast.
        for (t2 = x, i = 0; i < 8; i++) {

            x2 = this.sampleCurveX(t2) - x;
            if (Math.abs(x2) < epsilon) return t2;

            var d2 = this.sampleCurveDerivativeX(t2);
            if (Math.abs(d2) < 1e-6) break;

            t2 = t2 - x2 / d2;
        }

        // Fall back to the bisection method for reliability.
        t0 = 0.0;
        t1 = 1.0;
        t2 = x;

        if (t2 < t0) return t0;
        if (t2 > t1) return t1;

        while (t0 < t1) {

            x2 = this.sampleCurveX(t2);
            if (Math.abs(x2 - x) < epsilon) return t2;

            if (x > x2) {
                t0 = t2;
            } else {
                t1 = t2;
            }

            t2 = (t1 - t0) * 0.5 + t0;
        }

        // Failure.
        return t2;
    };

    UnitBezier.prototype.solve = function(x, epsilon) {
        return this.sampleCurveY(this.solveCurveX(x, epsilon));
    };

    /**
     * Enumeration for transition mode
     * @enum {number}
     * @readonly
     * @description Modes for specifying how transitions
     * between images are performed.
     */
    exports.TransitionMode = void 0;
    (function (TransitionMode) {
        /**
         * Default transitions.
         *
         * @description The viewer dynamically determines
         * whether transitions should be performed with or
         * without motion and blending for each transition
         * based on the underlying data.
         */
        TransitionMode[TransitionMode["Default"] = 0] = "Default";
        /**
         * Instantaneous transitions.
         *
         * @description All transitions are performed
         * without motion or blending.
         */
        TransitionMode[TransitionMode["Instantaneous"] = 1] = "Instantaneous";
    })(exports.TransitionMode || (exports.TransitionMode = {}));

    /**
     * @class Camera
     *
     * @classdesc Holds information about a camera.
     */
    class Camera {
        /**
         * Create a new camera instance.
         * @param {Transform} [transform] - Optional transform instance.
         */
        constructor(transform) {
            if (transform != null) {
                this._position = new Vector3().fromArray(transform.unprojectSfM([0, 0], 0));
                this._lookat = new Vector3().fromArray(transform.unprojectSfM([0, 0], 10));
                this._up = transform.upVector();
                this._focal = this._getFocal(transform);
            }
            else {
                this._position = new Vector3(0, 0, 0);
                this._lookat = new Vector3(1, 0, 0);
                this._up = new Vector3(0, 0, 1);
                this._focal = 1;
            }
        }
        /**
         * Get position.
         * @returns {THREE.Vector3} The position vector.
         */
        get position() {
            return this._position;
        }
        /**
         * Get lookat.
         * @returns {THREE.Vector3} The lookat vector.
         */
        get lookat() {
            return this._lookat;
        }
        /**
         * Get up.
         * @returns {THREE.Vector3} The up vector.
         */
        get up() {
            return this._up;
        }
        /**
         * Get focal.
         * @returns {number} The focal length.
         */
        get focal() {
            return this._focal;
        }
        /**
         * Set focal.
         */
        set focal(value) {
            this._focal = value;
        }
        /**
         * Update this camera to the linearly interpolated value of two other cameras.
         *
         * @param {Camera} a - First camera.
         * @param {Camera} b - Second camera.
         * @param {number} alpha - Interpolation value on the interval [0, 1].
         */
        lerpCameras(a, b, alpha) {
            this._position.subVectors(b.position, a.position).multiplyScalar(alpha).add(a.position);
            this._lookat.subVectors(b.lookat, a.lookat).multiplyScalar(alpha).add(a.lookat);
            this._up.subVectors(b.up, a.up).multiplyScalar(alpha).add(a.up);
            this._focal = (1 - alpha) * a.focal + alpha * b.focal;
        }
        /**
         * Copy the properties of another camera to this camera.
         *
         * @param {Camera} other - Another camera.
         */
        copy(other) {
            this._position.copy(other.position);
            this._lookat.copy(other.lookat);
            this._up.copy(other.up);
            this._focal = other.focal;
        }
        /**
         * Clone this camera.
         *
         * @returns {Camera} A camera with cloned properties equal to this camera.
         */
        clone() {
            let camera = new Camera();
            camera.position.copy(this._position);
            camera.lookat.copy(this._lookat);
            camera.up.copy(this._up);
            camera.focal = this._focal;
            return camera;
        }
        /**
         * Determine the distance between this camera and another camera.
         *
         * @param {Camera} other - Another camera.
         * @returns {number} The distance between the cameras.
         */
        diff(other) {
            let pd = this._position.distanceToSquared(other.position);
            let ld = this._lookat.distanceToSquared(other.lookat);
            let ud = this._up.distanceToSquared(other.up);
            let fd = 100 * Math.abs(this._focal - other.focal);
            return Math.max(pd, ld, ud, fd);
        }
        /**
         * Get the focal length based on the transform.
         *
         * @description Returns the focal length corresponding
         * to a 90 degree field of view for spherical
         * transforms.
         *
         * Returns the transform focal length for other
         * projection types.
         *
         * @returns {number} Focal length.
         */
        _getFocal(transform) {
            if (!isSpherical(transform.cameraType)) {
                return transform.focal;
            }
            return 0.5 / Math.tan(Math.PI / 2);
        }
    }

    const EPSILON = 1e-8;
    /**
     * @class Transform
     *
     * @classdesc Class used for calculating coordinate transformations
     * and projections.
     */
    class Transform {
        /**
         * Create a new transform instance.
         * @param {number} orientation - Image orientation.
         * @param {number} width - Image height.
         * @param {number} height - Image width.
         * @param {number} focal - Focal length.
         * @param {number} scale - Atomic scale.
         * @param {Array<number>} rotation - Rotation vector in three dimensions.
         * @param {Array<number>} translation - Translation vector in three dimensions.
         * @param {HTMLImageElement} image - Image for fallback size calculations.
         */
        constructor(orientation, width, height, scale, rotation, translation, image, textureScale, cameraParameters, cameraType) {
            this._orientation = this._getValue(orientation, 1);
            let imageWidth = image != null ? image.width : 4;
            let imageHeight = image != null ? image.height : 3;
            let keepOrientation = this._orientation < 5;
            this._width = this._getValue(width, keepOrientation ? imageWidth : imageHeight);
            this._height = this._getValue(height, keepOrientation ? imageHeight : imageWidth);
            this._basicAspect = keepOrientation ?
                this._width / this._height :
                this._height / this._width;
            this._basicWidth = keepOrientation ? width : height;
            this._basicHeight = keepOrientation ? height : width;
            const parameters = this._getCameraParameters(cameraParameters, cameraType);
            const focal = parameters[0];
            const ck1 = parameters[1];
            const ck2 = parameters[2];
            this._focal = this._getValue(focal, 1);
            this._scale = this._getValue(scale, 0);
            this._worldToCamera = this.createWorldToCamera(rotation, translation);
            this._worldToCameraInverse = new Matrix4()
                .copy(this._worldToCamera)
                .invert();
            this._scaledWorldToCamera =
                this._createScaledWorldToCamera(this._worldToCamera, this._scale);
            this._scaledWorldToCameraInverse = new Matrix4()
                .copy(this._scaledWorldToCamera)
                .invert();
            this._basicWorldToCamera = this._createBasicWorldToCamera(this._worldToCamera, orientation);
            this._textureScale = !!textureScale ? textureScale : [1, 1];
            this._ck1 = !!ck1 ? ck1 : 0;
            this._ck2 = !!ck2 ? ck2 : 0;
            this._cameraType = !!cameraType ?
                cameraType :
                "perspective";
            this._radialPeak = this._getRadialPeak(this._ck1, this._ck2);
        }
        get ck1() {
            return this._ck1;
        }
        get ck2() {
            return this._ck2;
        }
        get cameraType() {
            return this._cameraType;
        }
        /**
         * Get basic aspect.
         * @returns {number} The orientation adjusted aspect ratio.
         */
        get basicAspect() {
            return this._basicAspect;
        }
        /**
         * Get basic height.
         *
         * @description Does not fall back to image image height but
         * uses original value from API so can be faulty.
         *
         * @returns {number} The height of the basic version image
         * (adjusted for orientation).
         */
        get basicHeight() {
            return this._basicHeight;
        }
        get basicRt() {
            return this._basicWorldToCamera;
        }
        /**
         * Get basic width.
         *
         * @description Does not fall back to image image width but
         * uses original value from API so can be faulty.
         *
         * @returns {number} The width of the basic version image
         * (adjusted for orientation).
         */
        get basicWidth() {
            return this._basicWidth;
        }
        /**
         * Get focal.
         * @returns {number} The image focal length.
         */
        get focal() {
            return this._focal;
        }
        /**
         * Get height.
         *
         * @description Falls back to the image image height if
         * the API data is faulty.
         *
         * @returns {number} The orientation adjusted image height.
         */
        get height() {
            return this._height;
        }
        /**
         * Get orientation.
         * @returns {number} The image orientation.
         */
        get orientation() {
            return this._orientation;
        }
        /**
         * Get rt.
         * @returns {THREE.Matrix4} The extrinsic camera matrix.
         */
        get rt() {
            return this._worldToCamera;
        }
        /**
         * Get srt.
         * @returns {THREE.Matrix4} The scaled extrinsic camera matrix.
         */
        get srt() {
            return this._scaledWorldToCamera;
        }
        /**
         * Get srtInverse.
         * @returns {THREE.Matrix4} The scaled extrinsic camera matrix.
         */
        get srtInverse() {
            return this._scaledWorldToCameraInverse;
        }
        /**
         * Get scale.
         * @returns {number} The image atomic reconstruction scale.
         */
        get scale() {
            return this._scale;
        }
        /**
         * Get has valid scale.
         * @returns {boolean} Value indicating if the scale of the transform is valid.
         */
        get hasValidScale() {
            return this._scale > 1e-2 && this._scale < 50;
        }
        /**
         * Get radial peak.
         * @returns {number} Value indicating the radius where the radial
         * undistortion function peaks.
         */
        get radialPeak() {
            return this._radialPeak;
        }
        /**
         * Get width.
         *
         * @description Falls back to the image image width if
         * the API data is faulty.
         *
         * @returns {number} The orientation adjusted image width.
         */
        get width() {
            return this._width;
        }
        /**
         * Calculate the up vector for the image transform.
         *
         * @returns {THREE.Vector3} Normalized and orientation adjusted up vector.
         */
        upVector() {
            let rte = this._worldToCamera.elements;
            switch (this._orientation) {
                case 1:
                    return new Vector3(-rte[1], -rte[5], -rte[9]);
                case 3:
                    return new Vector3(rte[1], rte[5], rte[9]);
                case 6:
                    return new Vector3(-rte[0], -rte[4], -rte[8]);
                case 8:
                    return new Vector3(rte[0], rte[4], rte[8]);
                default:
                    return new Vector3(-rte[1], -rte[5], -rte[9]);
            }
        }
        /**
         * Calculate projector matrix for projecting 3D points to texture map
         * coordinates (u and v).
         *
         * @returns {THREE.Matrix4} Projection matrix for 3D point to texture
         * map coordinate calculations.
         */
        projectorMatrix() {
            let projector = this._normalizedToTextureMatrix();
            let f = this._focal;
            let projection = new Matrix4().set(f, 0, 0, 0, 0, f, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0);
            projector.multiply(projection);
            projector.multiply(this._worldToCamera);
            return projector;
        }
        /**
         * Project 3D world coordinates to basic coordinates.
         *
         * @param {Array<number>} point3d - 3D world coordinates.
         * @return {Array<number>} 2D basic coordinates.
         */
        projectBasic(point3d) {
            let sfm = this.projectSfM(point3d);
            return this._sfmToBasic(sfm);
        }
        /**
         * Unproject basic coordinates to 3D world coordinates.
         *
         * @param {Array<number>} basic - 2D basic coordinates.
         * @param {Array<number>} distance - Distance to unproject from camera center.
         * @param {boolean} [depth] - Treat the distance value as depth from camera center.
         *                            Only applicable for perspective images. Will be
         *                            ignored for spherical.
         * @returns {Array<number>} Unprojected 3D world coordinates.
         */
        unprojectBasic(basic, distance, depth) {
            let sfm = this._basicToSfm(basic);
            return this.unprojectSfM(sfm, distance, depth);
        }
        /**
         * Project 3D world coordinates to SfM coordinates.
         *
         * @param {Array<number>} point3d - 3D world coordinates.
         * @return {Array<number>} 2D SfM coordinates.
         */
        projectSfM(point3d) {
            let v = new Vector4(point3d[0], point3d[1], point3d[2], 1);
            v.applyMatrix4(this._worldToCamera);
            return this._bearingToSfm([v.x, v.y, v.z]);
        }
        /**
         * Unproject SfM coordinates to a 3D world coordinates.
         *
         * @param {Array<number>} sfm - 2D SfM coordinates.
         * @param {Array<number>} distance - Distance to unproject
         * from camera center.
         * @param {boolean} [depth] - Treat the distance value as
         * depth from camera center. Only applicable for perspective
         * images. Will be ignored for spherical.
         * @returns {Array<number>} Unprojected 3D world coordinates.
         */
        unprojectSfM(sfm, distance, depth) {
            const bearing = this._sfmToBearing(sfm);
            const unprojectedCamera = depth && !isSpherical(this._cameraType) ?
                new Vector4(distance * bearing[0] / bearing[2], distance * bearing[1] / bearing[2], distance, 1) :
                new Vector4(distance * bearing[0], distance * bearing[1], distance * bearing[2], 1);
            const unprojectedWorld = unprojectedCamera
                .applyMatrix4(this._worldToCameraInverse);
            return [
                unprojectedWorld.x / unprojectedWorld.w,
                unprojectedWorld.y / unprojectedWorld.w,
                unprojectedWorld.z / unprojectedWorld.w,
            ];
        }
        /**
         * Transform SfM coordinates to bearing vector (3D cartesian
         * coordinates on the unit sphere).
         *
         * @param {Array<number>} sfm - 2D SfM coordinates.
         * @returns {Array<number>} Bearing vector (3D cartesian coordinates
         * on the unit sphere).
         */
        _sfmToBearing(sfm) {
            if (isSpherical(this._cameraType)) {
                let lng = sfm[0] * 2 * Math.PI;
                let lat = -sfm[1] * 2 * Math.PI;
                let x = Math.cos(lat) * Math.sin(lng);
                let y = -Math.sin(lat);
                let z = Math.cos(lat) * Math.cos(lng);
                return [x, y, z];
            }
            else if (isFisheye(this._cameraType)) {
                let [dxn, dyn] = [sfm[0] / this._focal, sfm[1] / this._focal];
                const dTheta = Math.sqrt(dxn * dxn + dyn * dyn);
                let d = this._distortionFromDistortedRadius(dTheta, this._ck1, this._ck2, this._radialPeak);
                let theta = dTheta / d;
                let z = Math.cos(theta);
                let r = Math.sin(theta);
                const denomTheta = dTheta > EPSILON ? 1 / dTheta : 1;
                let x = r * dxn * denomTheta;
                let y = r * dyn * denomTheta;
                return [x, y, z];
            }
            else {
                let [dxn, dyn] = [sfm[0] / this._focal, sfm[1] / this._focal];
                const dr = Math.sqrt(dxn * dxn + dyn * dyn);
                let d = this._distortionFromDistortedRadius(dr, this._ck1, this._ck2, this._radialPeak);
                const xn = dxn / d;
                const yn = dyn / d;
                let v = new Vector3(xn, yn, 1);
                v.normalize();
                return [v.x, v.y, v.z];
            }
        }
        /** Compute distortion given the distorted radius.
         *
         *  Solves for d in the equation
         *    y = d(x, k1, k2) * x
         * given the distorted radius, y.
         */
        _distortionFromDistortedRadius(distortedRadius, k1, k2, radialPeak) {
            let d = 1.0;
            for (let i = 0; i < 10; i++) {
                let radius = distortedRadius / d;
                if (radius > radialPeak) {
                    radius = radialPeak;
                }
                d = 1 + k1 * Math.pow(radius, 2) + k2 * Math.pow(radius, 4);
            }
            return d;
        }
        /**
         * Transform bearing vector (3D cartesian coordiantes on the unit sphere) to
         * SfM coordinates.
         *
         * @param {Array<number>} bearing - Bearing vector (3D cartesian coordinates on the
         * unit sphere).
         * @returns {Array<number>} 2D SfM coordinates.
         */
        _bearingToSfm(bearing) {
            if (isSpherical(this._cameraType)) {
                let x = bearing[0];
                let y = bearing[1];
                let z = bearing[2];
                let lng = Math.atan2(x, z);
                let lat = Math.atan2(-y, Math.sqrt(x * x + z * z));
                return [lng / (2 * Math.PI), -lat / (2 * Math.PI)];
            }
            else if (isFisheye(this._cameraType)) {
                if (bearing[2] > 0) {
                    const [x, y, z] = bearing;
                    const r = Math.sqrt(x * x + y * y);
                    let theta = Math.atan2(r, z);
                    if (theta > this._radialPeak) {
                        theta = this._radialPeak;
                    }
                    const distortion = 1.0 + Math.pow(theta, 2) * (this._ck1 + Math.pow(theta, 2) * this._ck2);
                    const s = this._focal * distortion * theta / r;
                    return [s * x, s * y];
                }
                else {
                    return [
                        bearing[0] < 0 ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
                        bearing[1] < 0 ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
                    ];
                }
            }
            else {
                if (bearing[2] > 0) {
                    let [xn, yn] = [bearing[0] / bearing[2], bearing[1] / bearing[2]];
                    let r2 = xn * xn + yn * yn;
                    const rp2 = Math.pow(this._radialPeak, 2);
                    if (r2 > rp2) {
                        r2 = rp2;
                    }
                    const d = 1 + this._ck1 * r2 + this._ck2 * Math.pow(r2, 2);
                    return [
                        this._focal * d * xn,
                        this._focal * d * yn,
                    ];
                }
                else {
                    return [
                        bearing[0] < 0 ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
                        bearing[1] < 0 ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
                    ];
                }
            }
        }
        /**
         * Convert basic coordinates to SfM coordinates.
         *
         * @param {Array<number>} basic - 2D basic coordinates.
         * @returns {Array<number>} 2D SfM coordinates.
         */
        _basicToSfm(basic) {
            let rotatedX;
            let rotatedY;
            switch (this._orientation) {
                case 1:
                    rotatedX = basic[0];
                    rotatedY = basic[1];
                    break;
                case 3:
                    rotatedX = 1 - basic[0];
                    rotatedY = 1 - basic[1];
                    break;
                case 6:
                    rotatedX = basic[1];
                    rotatedY = 1 - basic[0];
                    break;
                case 8:
                    rotatedX = 1 - basic[1];
                    rotatedY = basic[0];
                    break;
                default:
                    rotatedX = basic[0];
                    rotatedY = basic[1];
                    break;
            }
            let w = this._width;
            let h = this._height;
            let s = Math.max(w, h);
            let sfmX = rotatedX * w / s - w / s / 2;
            let sfmY = rotatedY * h / s - h / s / 2;
            return [sfmX, sfmY];
        }
        /**
         * Convert SfM coordinates to basic coordinates.
         *
         * @param {Array<number>} sfm - 2D SfM coordinates.
         * @returns {Array<number>} 2D basic coordinates.
         */
        _sfmToBasic(sfm) {
            let w = this._width;
            let h = this._height;
            let s = Math.max(w, h);
            let rotatedX = (sfm[0] + w / s / 2) / w * s;
            let rotatedY = (sfm[1] + h / s / 2) / h * s;
            let basicX;
            let basicY;
            switch (this._orientation) {
                case 1:
                    basicX = rotatedX;
                    basicY = rotatedY;
                    break;
                case 3:
                    basicX = 1 - rotatedX;
                    basicY = 1 - rotatedY;
                    break;
                case 6:
                    basicX = 1 - rotatedY;
                    basicY = rotatedX;
                    break;
                case 8:
                    basicX = rotatedY;
                    basicY = 1 - rotatedX;
                    break;
                default:
                    basicX = rotatedX;
                    basicY = rotatedY;
                    break;
            }
            return [basicX, basicY];
        }
        /**
         * Checks a value and returns it if it exists and is larger than 0.
         * Fallbacks if it is null.
         *
         * @param {number} value - Value to check.
         * @param {number} fallback - Value to fall back to.
         * @returns {number} The value or its fallback value if it is not defined or negative.
         */
        _getValue(value, fallback) {
            return value != null && value > 0 ? value : fallback;
        }
        _getCameraParameters(value, cameraType) {
            if (isSpherical(cameraType)) {
                return [];
            }
            if (!value || value.length === 0) {
                return [1, 0, 0];
            }
            const padding = 3 - value.length;
            if (padding <= 0) {
                return value;
            }
            return value
                .concat(new Array(padding)
                .fill(0));
        }
        /**
         * Creates the extrinsic camera matrix [ R | t ].
         *
         * @param {Array<number>} rotation - Rotation vector in angle axis representation.
         * @param {Array<number>} translation - Translation vector.
         * @returns {THREE.Matrix4} Extrisic camera matrix.
         */
        createWorldToCamera(rotation, translation) {
            const axis = new Vector3(rotation[0], rotation[1], rotation[2]);
            const angle = axis.length();
            if (angle > 0) {
                axis.normalize();
            }
            const worldToCamera = new Matrix4();
            worldToCamera.makeRotationAxis(axis, angle);
            worldToCamera.setPosition(new Vector3(translation[0], translation[1], translation[2]));
            return worldToCamera;
        }
        /**
         * Calculates the scaled extrinsic camera matrix scale * [ R | t ].
         *
         * @param {THREE.Matrix4} worldToCamera - Extrisic camera matrix.
         * @param {number} scale - Scale factor.
         * @returns {THREE.Matrix4} Scaled extrisic camera matrix.
         */
        _createScaledWorldToCamera(worldToCamera, scale) {
            const scaledWorldToCamera = worldToCamera.clone();
            const elements = scaledWorldToCamera.elements;
            elements[12] = scale * elements[12];
            elements[13] = scale * elements[13];
            elements[14] = scale * elements[14];
            scaledWorldToCamera.scale(new Vector3(scale, scale, scale));
            return scaledWorldToCamera;
        }
        _createBasicWorldToCamera(rt, orientation) {
            const axis = new Vector3(0, 0, 1);
            let angle = 0;
            switch (orientation) {
                case 3:
                    angle = Math.PI;
                    break;
                case 6:
                    angle = Math.PI / 2;
                    break;
                case 8:
                    angle = 3 * Math.PI / 2;
                    break;
            }
            return new Matrix4()
                .makeRotationAxis(axis, angle)
                .multiply(rt);
        }
        _getRadialPeak(k1, k2) {
            const a = 5 * k2;
            const b = 3 * k1;
            const c = 1;
            const d = Math.pow(b, 2) - 4 * a * c;
            if (d < 0) {
                return undefined;
            }
            const root1 = (-b - Math.sqrt(d)) / 2 / a;
            const root2 = (-b + Math.sqrt(d)) / 2 / a;
            const minRoot = Math.min(root1, root2);
            const maxRoot = Math.max(root1, root2);
            return minRoot > 0 ?
                Math.sqrt(minRoot) :
                maxRoot > 0 ?
                    Math.sqrt(maxRoot) :
                    undefined;
        }
        /**
         * Calculate a transformation matrix from normalized coordinates for
         * texture map coordinates.
         *
         * @returns {THREE.Matrix4} Normalized coordinates to texture map
         * coordinates transformation matrix.
         */
        _normalizedToTextureMatrix() {
            const size = Math.max(this._width, this._height);
            const scaleX = this._orientation < 5 ? this._textureScale[0] : this._textureScale[1];
            const scaleY = this._orientation < 5 ? this._textureScale[1] : this._textureScale[0];
            const w = size / this._width * scaleX;
            const h = size / this._height * scaleY;
            switch (this._orientation) {
                case 1:
                    return new Matrix4().set(w, 0, 0, 0.5, 0, -h, 0, 0.5, 0, 0, 1, 0, 0, 0, 0, 1);
                case 3:
                    return new Matrix4().set(-w, 0, 0, 0.5, 0, h, 0, 0.5, 0, 0, 1, 0, 0, 0, 0, 1);
                case 6:
                    return new Matrix4().set(0, -h, 0, 0.5, -w, 0, 0, 0.5, 0, 0, 1, 0, 0, 0, 0, 1);
                case 8:
                    return new Matrix4().set(0, h, 0, 0.5, w, 0, 0, 0.5, 0, 0, 1, 0, 0, 0, 0, 1);
                default:
                    return new Matrix4().set(w, 0, 0, 0.5, 0, -h, 0, 0.5, 0, 0, 1, 0, 0, 0, 0, 1);
            }
        }
    }

    class StateBase {
        constructor(state) {
            this._spatial = new Spatial();
            this._referenceThreshold = 0.01;
            this._transitionMode = state.transitionMode;
            this._reference = state.reference;
            this._alpha = state.alpha;
            this._camera = state.camera.clone();
            this._zoom = state.zoom;
            this._currentIndex = state.currentIndex;
            this._trajectory = state.trajectory.slice();
            this._trajectoryTransforms = [];
            this._trajectoryCameras = [];
            for (let image of this._trajectory) {
                let translation = this._imageToTranslation(image, this._reference);
                let transform = new Transform(image.exifOrientation, image.width, image.height, image.scale, image.rotation, translation, image.image, undefined, image.cameraParameters, image.cameraType);
                this._trajectoryTransforms.push(transform);
                this._trajectoryCameras.push(new Camera(transform));
            }
            this._currentImage = this._trajectory.length > 0 ?
                this._trajectory[this._currentIndex] :
                null;
            this._previousImage = this._trajectory.length > 1 && this.currentIndex > 0 ?
                this._trajectory[this._currentIndex - 1] :
                null;
            this._currentCamera = this._trajectoryCameras.length > 0 ?
                this._trajectoryCameras[this._currentIndex].clone() :
                new Camera();
            this._previousCamera = this._trajectoryCameras.length > 1 && this.currentIndex > 0 ?
                this._trajectoryCameras[this._currentIndex - 1].clone() :
                this._currentCamera.clone();
        }
        get reference() {
            return this._reference;
        }
        get alpha() {
            return this._getAlpha();
        }
        get camera() {
            return this._camera;
        }
        get zoom() {
            return this._zoom;
        }
        get trajectory() {
            return this._trajectory;
        }
        get currentIndex() {
            return this._currentIndex;
        }
        get currentImage() {
            return this._currentImage;
        }
        get previousImage() {
            return this._previousImage;
        }
        get currentCamera() {
            return this._currentCamera;
        }
        get currentTransform() {
            return this._trajectoryTransforms.length > 0 ?
                this._trajectoryTransforms[this.currentIndex] : null;
        }
        get previousTransform() {
            return this._trajectoryTransforms.length > 1 && this.currentIndex > 0 ?
                this._trajectoryTransforms[this.currentIndex - 1] : null;
        }
        get motionless() {
            return this._motionless;
        }
        get transitionMode() {
            return this._transitionMode;
        }
        move(delta) { }
        moveTo(position) { }
        rotate(delta) { }
        rotateUnbounded(delta) { }
        rotateWithoutInertia(delta) { }
        rotateBasic(basicRotation) { }
        rotateBasicUnbounded(basicRotation) { }
        rotateBasicWithoutInertia(basicRotation) { }
        rotateToBasic(basic) { }
        setSpeed(speed) { }
        zoomIn(delta, reference) { }
        update(fps) { }
        setCenter(center) { }
        setZoom(zoom) { }
        dolly(delta) { }
        orbit(rotation) { }
        setViewMatrix(matrix) { }
        truck(direction) { }
        append(images) {
            if (images.length < 1) {
                throw Error("Trajectory can not be empty");
            }
            if (this._currentIndex < 0) {
                this.set(images);
            }
            else {
                this._trajectory = this._trajectory.concat(images);
                this._appendToTrajectories(images);
            }
        }
        prepend(images) {
            if (images.length < 1) {
                throw Error("Trajectory can not be empty");
            }
            this._trajectory = images.slice().concat(this._trajectory);
            this._currentIndex += images.length;
            this._setCurrentImage();
            let referenceReset = this._setReference(this._currentImage);
            if (referenceReset) {
                this._setTrajectories();
            }
            else {
                this._prependToTrajectories(images);
            }
            this._setCurrentCamera();
        }
        remove(n) {
            if (n < 0) {
                throw Error("n must be a positive integer");
            }
            if (this._currentIndex - 1 < n) {
                throw Error("Current and previous images can not be removed");
            }
            for (let i = 0; i < n; i++) {
                this._trajectory.shift();
                this._trajectoryTransforms.shift();
                this._trajectoryCameras.shift();
                this._currentIndex--;
            }
            this._setCurrentImage();
        }
        clearPrior() {
            if (this._currentIndex > 0) {
                this.remove(this._currentIndex - 1);
            }
        }
        clear() {
            this.cut();
            if (this._currentIndex > 0) {
                this.remove(this._currentIndex - 1);
            }
        }
        cut() {
            while (this._trajectory.length - 1 > this._currentIndex) {
                this._trajectory.pop();
                this._trajectoryTransforms.pop();
                this._trajectoryCameras.pop();
            }
        }
        set(images) {
            this._setTrajectory(images);
            this._setCurrentImage();
            this._setReference(this._currentImage);
            this._setTrajectories();
            this._setCurrentCamera();
        }
        getCenter() {
            return this._currentImage != null ?
                this.currentTransform.projectBasic(this._camera.lookat.toArray()) :
                [0.5, 0.5];
        }
        setTransitionMode(mode) {
            this._transitionMode = mode;
        }
        _getAlpha() { return 1; }
        _setCurrent() {
            this._setCurrentImage();
            let referenceReset = this._setReference(this._currentImage);
            if (referenceReset) {
                this._setTrajectories();
            }
            this._setCurrentCamera();
        }
        _setCurrentCamera() {
            this._currentCamera = this._trajectoryCameras[this._currentIndex].clone();
            this._previousCamera = this._currentIndex > 0 ?
                this._trajectoryCameras[this._currentIndex - 1].clone() :
                this._currentCamera.clone();
        }
        _motionlessTransition() {
            let imagesSet = this._currentImage != null && this._previousImage != null;
            return imagesSet && (this._transitionMode === exports.TransitionMode.Instantaneous || !(this._currentImage.merged &&
                this._previousImage.merged &&
                this._withinOriginalDistance() &&
                this._sameConnectedComponent()));
        }
        _setReference(image) {
            // do not reset reference if image is within threshold distance
            if (Math.abs(image.lngLat.lat - this.reference.lat) < this._referenceThreshold &&
                Math.abs(image.lngLat.lng - this.reference.lng) < this._referenceThreshold) {
                return false;
            }
            // do not reset reference if previous image exist and transition is with motion
            if (this._previousImage != null && !this._motionlessTransition()) {
                return false;
            }
            this._reference.lat = image.lngLat.lat;
            this._reference.lng = image.lngLat.lng;
            this._reference.alt = image.computedAltitude;
            return true;
        }
        _setCurrentImage() {
            this._currentImage = this._trajectory.length > 0 ?
                this._trajectory[this._currentIndex] :
                null;
            this._previousImage = this._currentIndex > 0 ?
                this._trajectory[this._currentIndex - 1] :
                null;
        }
        _setTrajectory(images) {
            if (images.length < 1) {
                throw new ArgumentMapillaryError("Trajectory can not be empty");
            }
            if (this._currentImage != null) {
                this._trajectory = [this._currentImage].concat(images);
                this._currentIndex = 1;
            }
            else {
                this._trajectory = images.slice();
                this._currentIndex = 0;
            }
        }
        _setTrajectories() {
            this._trajectoryTransforms.length = 0;
            this._trajectoryCameras.length = 0;
            this._appendToTrajectories(this._trajectory);
        }
        _appendToTrajectories(images) {
            for (let image of images) {
                if (!image.assetsCached) {
                    throw new ArgumentMapillaryError("Assets must be cached when image is added to trajectory");
                }
                let translation = this._imageToTranslation(image, this.reference);
                let transform = new Transform(image.exifOrientation, image.width, image.height, image.scale, image.rotation, translation, image.image, undefined, image.cameraParameters, image.cameraType);
                this._trajectoryTransforms.push(transform);
                this._trajectoryCameras.push(new Camera(transform));
            }
        }
        _prependToTrajectories(images) {
            for (let image of images.reverse()) {
                if (!image.assetsCached) {
                    throw new ArgumentMapillaryError("Assets must be cached when added to trajectory");
                }
                let translation = this._imageToTranslation(image, this.reference);
                let transform = new Transform(image.exifOrientation, image.width, image.height, image.scale, image.rotation, translation, image.image, undefined, image.cameraParameters, image.cameraType);
                this._trajectoryTransforms.unshift(transform);
                this._trajectoryCameras.unshift(new Camera(transform));
            }
        }
        _imageToTranslation(image, reference) {
            return computeTranslation({ alt: image.computedAltitude, lat: image.lngLat.lat, lng: image.lngLat.lng }, image.rotation, reference);
        }
        _sameConnectedComponent() {
            let current = this._currentImage;
            let previous = this._previousImage;
            return !!current && !!previous &&
                current.mergeId === previous.mergeId;
        }
        _withinOriginalDistance() {
            let current = this._currentImage;
            let previous = this._previousImage;
            if (!current || !previous) {
                return true;
            }
            // 50 km/h moves 28m in 2s
            let distance = this._spatial.distanceFromLngLat(current.originalLngLat.lng, current.originalLngLat.lat, previous.originalLngLat.lng, previous.originalLngLat.lat);
            return distance < 25;
        }
    }

    class EulerRotationDelta {
        constructor(phi, theta) {
            this._phi = phi;
            this._theta = theta;
        }
        get phi() {
            return this._phi;
        }
        set phi(value) {
            this._phi = value;
        }
        get theta() {
            return this._theta;
        }
        set theta(value) {
            this._theta = value;
        }
        get isZero() {
            return this._phi === 0 && this._theta === 0;
        }
        copy(delta) {
            this._phi = delta.phi;
            this._theta = delta.theta;
        }
        lerp(other, alpha) {
            this._phi = (1 - alpha) * this._phi + alpha * other.phi;
            this._theta = (1 - alpha) * this._theta + alpha * other.theta;
        }
        multiply(value) {
            this._phi *= value;
            this._theta *= value;
        }
        threshold(value) {
            this._phi = Math.abs(this._phi) > value ? this._phi : 0;
            this._theta = Math.abs(this._theta) > value ? this._theta : 0;
        }
        lengthSquared() {
            return this._phi * this._phi + this._theta * this._theta;
        }
        reset() {
            this._phi = 0;
            this._theta = 0;
        }
    }

    class InteractiveStateBase extends StateBase {
        constructor(state) {
            super(state);
            this._animationSpeed = 1 / 40;
            this._rotationDelta = new EulerRotationDelta(0, 0);
            this._requestedRotationDelta = null;
            this._basicRotation = [0, 0];
            this._requestedBasicRotation = null;
            this._requestedBasicRotationUnbounded = null;
            this._rotationAcceleration = 0.86;
            this._rotationIncreaseAlpha = 0.97;
            this._rotationDecreaseAlpha = 0.9;
            this._rotationThreshold = 1e-3;
            this._unboundedRotationAlpha = 0.8;
            this._desiredZoom = state.zoom;
            this._minZoom = 0;
            this._maxZoom = 3;
            this._lookatDepth = 10;
            this._desiredLookat = null;
            this._desiredCenter = null;
        }
        rotate(rotationDelta) {
            if (this._currentImage == null) {
                return;
            }
            if (rotationDelta.phi === 0 && rotationDelta.theta === 0) {
                return;
            }
            this._desiredZoom = this._zoom;
            this._desiredLookat = null;
            this._requestedBasicRotation = null;
            if (this._requestedRotationDelta != null) {
                this._requestedRotationDelta.phi = this._requestedRotationDelta.phi + rotationDelta.phi;
                this._requestedRotationDelta.theta = this._requestedRotationDelta.theta + rotationDelta.theta;
            }
            else {
                this._requestedRotationDelta = new EulerRotationDelta(rotationDelta.phi, rotationDelta.theta);
            }
        }
        rotateUnbounded(delta) {
            if (this._currentImage == null) {
                return;
            }
            this._requestedBasicRotation = null;
            this._requestedRotationDelta = null;
            this._applyRotation(delta, this._currentCamera);
            this._applyRotation(delta, this._previousCamera);
            if (!this._desiredLookat) {
                return;
            }
            const q = new Quaternion().setFromUnitVectors(this._currentCamera.up, new Vector3(0, 0, 1));
            const qInverse = q.clone().invert();
            const offset = new Vector3()
                .copy(this._desiredLookat)
                .sub(this._camera.position)
                .applyQuaternion(q);
            const length = offset.length();
            let phi = Math.atan2(offset.y, offset.x);
            phi += delta.phi;
            let theta = Math.atan2(Math.sqrt(offset.x * offset.x + offset.y * offset.y), offset.z);
            theta += delta.theta;
            theta = Math.max(0.1, Math.min(Math.PI - 0.1, theta));
            offset.x = Math.sin(theta) * Math.cos(phi);
            offset.y = Math.sin(theta) * Math.sin(phi);
            offset.z = Math.cos(theta);
            offset.applyQuaternion(qInverse);
            this._desiredLookat
                .copy(this._camera.position)
                .add(offset.multiplyScalar(length));
        }
        rotateWithoutInertia(rotationDelta) {
            if (this._currentImage == null) {
                return;
            }
            this._desiredZoom = this._zoom;
            this._desiredLookat = null;
            this._requestedBasicRotation = null;
            this._requestedRotationDelta = null;
            const threshold = Math.PI / (10 * Math.pow(2, this._zoom));
            const delta = {
                phi: this._spatial.clamp(rotationDelta.phi, -threshold, threshold),
                theta: this._spatial.clamp(rotationDelta.theta, -threshold, threshold),
            };
            this._applyRotation(delta, this._currentCamera);
            this._applyRotation(delta, this._previousCamera);
        }
        rotateBasic(basicRotation) {
            if (this._currentImage == null) {
                return;
            }
            this._desiredZoom = this._zoom;
            this._desiredLookat = null;
            this._requestedRotationDelta = null;
            if (this._requestedBasicRotation != null) {
                this._requestedBasicRotation[0] += basicRotation[0];
                this._requestedBasicRotation[1] += basicRotation[1];
                let threshold = 0.05 / Math.pow(2, this._zoom);
                this._requestedBasicRotation[0] =
                    this._spatial.clamp(this._requestedBasicRotation[0], -threshold, threshold);
                this._requestedBasicRotation[1] =
                    this._spatial.clamp(this._requestedBasicRotation[1], -threshold, threshold);
            }
            else {
                this._requestedBasicRotation = basicRotation.slice();
            }
        }
        rotateBasicUnbounded(basicRotation) {
            if (this._currentImage == null) {
                return;
            }
            if (this._requestedBasicRotationUnbounded != null) {
                this._requestedBasicRotationUnbounded[0] += basicRotation[0];
                this._requestedBasicRotationUnbounded[1] += basicRotation[1];
            }
            else {
                this._requestedBasicRotationUnbounded = basicRotation.slice();
            }
        }
        rotateBasicWithoutInertia(basic) {
            if (this._currentImage == null) {
                return;
            }
            this._desiredZoom = this._zoom;
            this._desiredLookat = null;
            this._requestedRotationDelta = null;
            this._requestedBasicRotation = null;
            const threshold = 0.05 / Math.pow(2, this._zoom);
            const basicRotation = basic.slice();
            basicRotation[0] = this._spatial.clamp(basicRotation[0], -threshold, threshold);
            basicRotation[1] = this._spatial.clamp(basicRotation[1], -threshold, threshold);
            this._applyRotationBasic(basicRotation);
        }
        rotateToBasic(basic) {
            if (this._currentImage == null) {
                return;
            }
            this._desiredZoom = this._zoom;
            this._desiredLookat = null;
            basic[0] = this._spatial.clamp(basic[0], 0, 1);
            basic[1] = this._spatial.clamp(basic[1], 0, 1);
            let lookat = this.currentTransform.unprojectBasic(basic, this._lookatDepth);
            this._currentCamera.lookat.fromArray(lookat);
        }
        zoomIn(delta, reference) {
            if (this._currentImage == null) {
                return;
            }
            this._desiredZoom = Math.max(this._minZoom, Math.min(this._maxZoom, this._desiredZoom + delta));
            let currentCenter = this.currentTransform.projectBasic(this._currentCamera.lookat.toArray());
            let currentCenterX = currentCenter[0];
            let currentCenterY = currentCenter[1];
            let zoom0 = Math.pow(2, this._zoom);
            let zoom1 = Math.pow(2, this._desiredZoom);
            let refX = reference[0];
            let refY = reference[1];
            if (isSpherical(this.currentTransform.cameraType)) {
                if (refX - currentCenterX > 0.5) {
                    refX = refX - 1;
                }
                else if (currentCenterX - refX > 0.5) {
                    refX = 1 + refX;
                }
            }
            let newCenterX = refX - zoom0 / zoom1 * (refX - currentCenterX);
            let newCenterY = refY - zoom0 / zoom1 * (refY - currentCenterY);
            if (isSpherical(this._currentImage.cameraType)) {
                newCenterX = this._spatial
                    .wrap(newCenterX + this._basicRotation[0], 0, 1);
                newCenterY = this._spatial
                    .clamp(newCenterY + this._basicRotation[1], 0.05, 0.95);
            }
            else {
                newCenterX = this._spatial.clamp(newCenterX, 0, 1);
                newCenterY = this._spatial.clamp(newCenterY, 0, 1);
            }
            this._desiredLookat = new Vector3()
                .fromArray(this.currentTransform.unprojectBasic([newCenterX, newCenterY], this._lookatDepth));
        }
        setCenter(center) {
            this._desiredLookat = null;
            this._requestedRotationDelta = null;
            this._requestedBasicRotation = null;
            this._desiredZoom = this._zoom;
            let clamped = [
                this._spatial.clamp(center[0], 0, 1),
                this._spatial.clamp(center[1], 0, 1),
            ];
            if (this._currentImage == null) {
                this._desiredCenter = clamped;
                return;
            }
            this._desiredCenter = null;
            let currentLookat = new Vector3()
                .fromArray(this.currentTransform.unprojectBasic(clamped, this._lookatDepth));
            let previousTransform = this.previousTransform != null ?
                this.previousTransform :
                this.currentTransform;
            let previousLookat = new Vector3()
                .fromArray(previousTransform.unprojectBasic(clamped, this._lookatDepth));
            this._currentCamera.lookat.copy(currentLookat);
            this._previousCamera.lookat.copy(previousLookat);
        }
        setZoom(zoom) {
            this._desiredLookat = null;
            this._requestedRotationDelta = null;
            this._requestedBasicRotation = null;
            this._zoom = this._spatial.clamp(zoom, this._minZoom, this._maxZoom);
            this._desiredZoom = this._zoom;
        }
        _applyRotation(delta, camera) {
            if (camera == null) {
                return;
            }
            let q = new Quaternion().setFromUnitVectors(camera.up, new Vector3(0, 0, 1));
            let qInverse = q.clone().invert();
            let offset = new Vector3();
            offset.copy(camera.lookat).sub(camera.position);
            offset.applyQuaternion(q);
            let length = offset.length();
            let phi = Math.atan2(offset.y, offset.x);
            phi += delta.phi;
            let theta = Math.atan2(Math.sqrt(offset.x * offset.x + offset.y * offset.y), offset.z);
            theta += delta.theta;
            theta = Math.max(0.1, Math.min(Math.PI - 0.1, theta));
            offset.x = Math.sin(theta) * Math.cos(phi);
            offset.y = Math.sin(theta) * Math.sin(phi);
            offset.z = Math.cos(theta);
            offset.applyQuaternion(qInverse);
            camera.lookat.copy(camera.position).add(offset.multiplyScalar(length));
        }
        _applyRotationBasic(basicRotation) {
            let currentImage = this._currentImage;
            let previousImage = this._previousImage != null ?
                this.previousImage :
                this.currentImage;
            let currentCamera = this._currentCamera;
            let previousCamera = this._previousCamera;
            let currentTransform = this.currentTransform;
            let previousTransform = this.previousTransform != null ?
                this.previousTransform :
                this.currentTransform;
            let currentBasic = currentTransform.projectBasic(currentCamera.lookat.toArray());
            let previousBasic = previousTransform.projectBasic(previousCamera.lookat.toArray());
            if (isSpherical(currentImage.cameraType)) {
                currentBasic[0] = this._spatial.wrap(currentBasic[0] + basicRotation[0], 0, 1);
                currentBasic[1] = this._spatial.clamp(currentBasic[1] + basicRotation[1], 0.05, 0.95);
            }
            else {
                currentBasic[0] = this._spatial.clamp(currentBasic[0] + basicRotation[0], 0, 1);
                currentBasic[1] = this._spatial.clamp(currentBasic[1] + basicRotation[1], 0, 1);
            }
            if (isSpherical(previousImage.cameraType)) {
                previousBasic[0] = this._spatial.wrap(previousBasic[0] + basicRotation[0], 0, 1);
                previousBasic[1] = this._spatial.clamp(previousBasic[1] + basicRotation[1], 0.05, 0.95);
            }
            else {
                previousBasic[0] = this._spatial.clamp(previousBasic[0] + basicRotation[0], 0, 1);
                previousBasic[1] = this._spatial.clamp(currentBasic[1] + basicRotation[1], 0, 1);
            }
            let currentLookat = currentTransform.unprojectBasic(currentBasic, this._lookatDepth);
            currentCamera.lookat.fromArray(currentLookat);
            let previousLookat = previousTransform.unprojectBasic(previousBasic, this._lookatDepth);
            previousCamera.lookat.fromArray(previousLookat);
        }
        _updateZoom(animationSpeed) {
            let diff = this._desiredZoom - this._zoom;
            let sign = diff > 0 ? 1 : diff < 0 ? -1 : 0;
            if (diff === 0) {
                return;
            }
            else if (Math.abs(diff) < 2e-3) {
                this._zoom = this._desiredZoom;
                if (this._desiredLookat != null) {
                    this._desiredLookat = null;
                }
            }
            else {
                this._zoom += sign * Math.max(Math.abs(5 * animationSpeed * diff), 2e-3);
            }
        }
        _updateLookat(animationSpeed) {
            if (this._desiredLookat === null) {
                return;
            }
            let diff = this._desiredLookat.distanceToSquared(this._currentCamera.lookat);
            if (Math.abs(diff) < 1e-6) {
                this._currentCamera.lookat.copy(this._desiredLookat);
                this._desiredLookat = null;
            }
            else {
                this._currentCamera.lookat.lerp(this._desiredLookat, 5 * animationSpeed);
            }
        }
        _updateRotation() {
            if (this._requestedRotationDelta != null) {
                let length = this._rotationDelta.lengthSquared();
                let requestedLength = this._requestedRotationDelta.lengthSquared();
                if (requestedLength > length) {
                    this._rotationDelta.lerp(this._requestedRotationDelta, this._rotationIncreaseAlpha);
                }
                else {
                    this._rotationDelta.lerp(this._requestedRotationDelta, this._rotationDecreaseAlpha);
                }
                this._requestedRotationDelta = null;
                return;
            }
            if (this._rotationDelta.isZero) {
                return;
            }
            const alpha = isSpherical(this.currentImage.cameraType) ?
                1 : this._alpha;
            this._rotationDelta.multiply(this._rotationAcceleration * alpha);
            this._rotationDelta.threshold(this._rotationThreshold);
        }
        _updateRotationBasic() {
            if (this._requestedBasicRotation != null) {
                let x = this._basicRotation[0];
                let y = this._basicRotation[1];
                let reqX = this._requestedBasicRotation[0];
                let reqY = this._requestedBasicRotation[1];
                if (Math.abs(reqX) > Math.abs(x)) {
                    this._basicRotation[0] = (1 - this._rotationIncreaseAlpha) * x + this._rotationIncreaseAlpha * reqX;
                }
                else {
                    this._basicRotation[0] = (1 - this._rotationDecreaseAlpha) * x + this._rotationDecreaseAlpha * reqX;
                }
                if (Math.abs(reqY) > Math.abs(y)) {
                    this._basicRotation[1] = (1 - this._rotationIncreaseAlpha) * y + this._rotationIncreaseAlpha * reqY;
                }
                else {
                    this._basicRotation[1] = (1 - this._rotationDecreaseAlpha) * y + this._rotationDecreaseAlpha * reqY;
                }
                this._requestedBasicRotation = null;
                return;
            }
            if (this._requestedBasicRotationUnbounded != null) {
                let reqX = this._requestedBasicRotationUnbounded[0];
                let reqY = this._requestedBasicRotationUnbounded[1];
                if (Math.abs(reqX) > 0) {
                    this._basicRotation[0] = (1 - this._unboundedRotationAlpha) * this._basicRotation[0] + this._unboundedRotationAlpha * reqX;
                }
                if (Math.abs(reqY) > 0) {
                    this._basicRotation[1] = (1 - this._unboundedRotationAlpha) * this._basicRotation[1] + this._unboundedRotationAlpha * reqY;
                }
                if (this._desiredLookat != null) {
                    let desiredBasicLookat = this.currentTransform.projectBasic(this._desiredLookat.toArray());
                    desiredBasicLookat[0] += reqX;
                    desiredBasicLookat[1] += reqY;
                    this._desiredLookat = new Vector3()
                        .fromArray(this.currentTransform.unprojectBasic(desiredBasicLookat, this._lookatDepth));
                }
                this._requestedBasicRotationUnbounded = null;
            }
            if (this._basicRotation[0] === 0 && this._basicRotation[1] === 0) {
                return;
            }
            this._basicRotation[0] = this._rotationAcceleration * this._basicRotation[0];
            this._basicRotation[1] = this._rotationAcceleration * this._basicRotation[1];
            if (Math.abs(this._basicRotation[0]) < this._rotationThreshold / Math.pow(2, this._zoom) &&
                Math.abs(this._basicRotation[1]) < this._rotationThreshold / Math.pow(2, this._zoom)) {
                this._basicRotation = [0, 0];
            }
        }
        _clearRotation() {
            if (isSpherical(this._currentImage.cameraType)) {
                return;
            }
            if (this._requestedRotationDelta != null) {
                this._requestedRotationDelta = null;
            }
            if (!this._rotationDelta.isZero) {
                this._rotationDelta.reset();
            }
            if (this._requestedBasicRotation != null) {
                this._requestedBasicRotation = null;
            }
            if (this._basicRotation[0] > 0 || this._basicRotation[1] > 0) {
                this._basicRotation = [0, 0];
            }
        }
        _setDesiredCenter() {
            if (this._desiredCenter == null) {
                return;
            }
            let lookatDirection = new Vector3()
                .fromArray(this.currentTransform.unprojectBasic(this._desiredCenter, this._lookatDepth))
                .sub(this._currentCamera.position);
            this._currentCamera.lookat.copy(this._currentCamera.position.clone().add(lookatDirection));
            this._previousCamera.lookat.copy(this._previousCamera.position.clone().add(lookatDirection));
            this._desiredCenter = null;
        }
        _setDesiredZoom() {
            this._desiredZoom =
                isSpherical(this._currentImage.cameraType) ||
                    this._previousImage == null ?
                    this._zoom : 0;
        }
    }

    class TraversingState extends InteractiveStateBase {
        constructor(state) {
            super(state);
            this._adjustCameras();
            this._motionless = this._motionlessTransition();
            this._baseAlpha = this._alpha;
            this._speedCoefficient = 1;
            this._unitBezier =
                new TraversingState._interpolator(0.74, 0.67, 0.38, 0.96);
            this._useBezier = false;
        }
        static register(interpolator) {
            TraversingState._interpolator = interpolator;
        }
        append(images) {
            let emptyTrajectory = this._trajectory.length === 0;
            if (emptyTrajectory) {
                this._resetTransition();
            }
            super.append(images);
            if (emptyTrajectory) {
                this._setDesiredCenter();
                this._setDesiredZoom();
            }
        }
        prepend(images) {
            let emptyTrajectory = this._trajectory.length === 0;
            if (emptyTrajectory) {
                this._resetTransition();
            }
            super.prepend(images);
            if (emptyTrajectory) {
                this._setDesiredCenter();
                this._setDesiredZoom();
            }
        }
        set(images) {
            super.set(images);
            this._desiredLookat = null;
            this._resetTransition();
            this._clearRotation();
            this._setDesiredCenter();
            this._setDesiredZoom();
            if (this._trajectory.length < 3) {
                this._useBezier = true;
            }
        }
        setSpeed(speed) {
            this._speedCoefficient = this._spatial.clamp(speed, 0, 10);
        }
        update(fps) {
            if (this._alpha === 1 && this._currentIndex + this._alpha < this._trajectory.length) {
                this._currentIndex += 1;
                this._useBezier = this._trajectory.length < 3 &&
                    this._currentIndex + 1 === this._trajectory.length;
                this._setCurrent();
                this._resetTransition();
                this._clearRotation();
                this._desiredZoom =
                    isSpherical(this._currentImage.cameraType) ?
                        this._zoom : 0;
                this._desiredLookat = null;
            }
            let animationSpeed = this._animationSpeed * (60 / fps);
            this._baseAlpha = Math.min(1, this._baseAlpha + this._speedCoefficient * animationSpeed);
            if (this._useBezier) {
                this._alpha = this._unitBezier.solve(this._baseAlpha);
            }
            else {
                this._alpha = this._baseAlpha;
            }
            this._updateRotation();
            if (!this._rotationDelta.isZero) {
                this._applyRotation(this._rotationDelta, this._previousCamera);
                this._applyRotation(this._rotationDelta, this._currentCamera);
            }
            this._updateRotationBasic();
            if (this._basicRotation[0] !== 0 || this._basicRotation[1] !== 0) {
                this._applyRotationBasic(this._basicRotation);
            }
            this._updateZoom(animationSpeed);
            this._updateLookat(animationSpeed);
            this._camera.lerpCameras(this._previousCamera, this._currentCamera, this.alpha);
        }
        _getAlpha() {
            return this._motionless ? Math.ceil(this._alpha) : this._alpha;
        }
        _setCurrentCamera() {
            super._setCurrentCamera();
            this._adjustCameras();
        }
        _adjustCameras() {
            if (this._previousImage == null) {
                return;
            }
            let lookat = this._camera.lookat.clone().sub(this._camera.position);
            this._previousCamera.lookat.copy(lookat.clone().add(this._previousCamera.position));
            if (isSpherical(this._currentImage.cameraType)) {
                this._currentCamera.lookat.copy(lookat.clone().add(this._currentCamera.position));
            }
        }
        _resetTransition() {
            this._alpha = 0;
            this._baseAlpha = 0;
            this._motionless = this._motionlessTransition();
        }
    }

    class ComponentService {
        constructor(container, navigator) {
            this._components = {};
            for (const componentName in ComponentService.registeredComponents) {
                if (!ComponentService.registeredComponents.hasOwnProperty(componentName)) {
                    continue;
                }
                const component = ComponentService.registeredComponents[componentName];
                this._components[componentName] = {
                    active: false,
                    component: new component(componentName, container, navigator),
                };
            }
            this._coverComponent = new ComponentService.registeredCoverComponent("cover", container, navigator);
            this._coverComponent.activate();
            this._coverActivated = true;
        }
        static register(component) {
            if (ComponentService.registeredComponents[component.componentName] === undefined) {
                ComponentService.registeredComponents[component.componentName] = component;
            }
        }
        static registerCover(coverComponent) {
            ComponentService.registeredCoverComponent = coverComponent;
        }
        get coverActivated() {
            return this._coverActivated;
        }
        activateCover() {
            if (this._coverActivated) {
                return;
            }
            this._coverActivated = true;
            for (const componentName in this._components) {
                if (!this._components.hasOwnProperty(componentName)) {
                    continue;
                }
                const component = this._components[componentName];
                if (component.active) {
                    component.component.deactivate();
                }
            }
        }
        deactivateCover() {
            if (!this._coverActivated) {
                return;
            }
            this._coverActivated = false;
            for (const componentName in this._components) {
                if (!this._components.hasOwnProperty(componentName)) {
                    continue;
                }
                const component = this._components[componentName];
                if (component.active) {
                    component.component.activate();
                }
            }
        }
        activate(name) {
            this._checkName(name);
            this._components[name].active = true;
            if (!this._coverActivated) {
                this.get(name).activate();
            }
        }
        configure(name, conf) {
            this._checkName(name);
            this.get(name).configure(conf);
        }
        deactivate(name) {
            this._checkName(name);
            this._components[name].active = false;
            if (!this._coverActivated) {
                this.get(name).deactivate();
            }
        }
        get(name) {
            return this._components[name].component;
        }
        getCover() {
            return this._coverComponent;
        }
        remove() {
            this._coverComponent.deactivate();
            for (const componentName in this._components) {
                if (!this._components.hasOwnProperty(componentName)) {
                    continue;
                }
                this._components[componentName].component.deactivate();
            }
        }
        _checkName(name) {
            if (!(name in this._components)) {
                throw new ArgumentMapillaryError(`Component does not exist: ${name}`);
            }
        }
    }
    ComponentService.registeredComponents = {};

    var nativeIsArray = Array.isArray;
    var toString$2 = Object.prototype.toString;

    var xIsArray = nativeIsArray || isArray;

    function isArray(obj) {
        return toString$2.call(obj) === "[object Array]"
    }

    var version = "2";

    VirtualPatch.NONE = 0;
    VirtualPatch.VTEXT = 1;
    VirtualPatch.VNODE = 2;
    VirtualPatch.WIDGET = 3;
    VirtualPatch.PROPS = 4;
    VirtualPatch.ORDER = 5;
    VirtualPatch.INSERT = 6;
    VirtualPatch.REMOVE = 7;
    VirtualPatch.THUNK = 8;

    var vpatch = VirtualPatch;

    function VirtualPatch(type, vNode, patch) {
        this.type = Number(type);
        this.vNode = vNode;
        this.patch = patch;
    }

    VirtualPatch.prototype.version = version;
    VirtualPatch.prototype.type = "VirtualPatch";

    var isVnode = isVirtualNode;

    function isVirtualNode(x) {
        return x && x.type === "VirtualNode" && x.version === version
    }

    var isVtext = isVirtualText;

    function isVirtualText(x) {
        return x && x.type === "VirtualText" && x.version === version
    }

    var isWidget_1 = isWidget;

    function isWidget(w) {
        return w && w.type === "Widget"
    }

    var isThunk_1 = isThunk;

    function isThunk(t) {
        return t && t.type === "Thunk"
    }

    var handleThunk_1 = handleThunk;

    function handleThunk(a, b) {
        var renderedA = a;
        var renderedB = b;

        if (isThunk_1(b)) {
            renderedB = renderThunk(b, a);
        }

        if (isThunk_1(a)) {
            renderedA = renderThunk(a, null);
        }

        return {
            a: renderedA,
            b: renderedB
        }
    }

    function renderThunk(thunk, previous) {
        var renderedThunk = thunk.vnode;

        if (!renderedThunk) {
            renderedThunk = thunk.vnode = thunk.render(previous);
        }

        if (!(isVnode(renderedThunk) ||
                isVtext(renderedThunk) ||
                isWidget_1(renderedThunk))) {
            throw new Error("thunk did not return a valid node");
        }

        return renderedThunk
    }

    var isObject = function isObject(x) {
        return typeof x === 'object' && x !== null;
    };

    var isVhook = isHook;

    function isHook(hook) {
        return hook &&
          (typeof hook.hook === "function" && !hook.hasOwnProperty("hook") ||
           typeof hook.unhook === "function" && !hook.hasOwnProperty("unhook"))
    }

    var diffProps_1 = diffProps;

    function diffProps(a, b) {
        var diff;

        for (var aKey in a) {
            if (!(aKey in b)) {
                diff = diff || {};
                diff[aKey] = undefined;
            }

            var aValue = a[aKey];
            var bValue = b[aKey];

            if (aValue === bValue) {
                continue
            } else if (isObject(aValue) && isObject(bValue)) {
                if (getPrototype$1(bValue) !== getPrototype$1(aValue)) {
                    diff = diff || {};
                    diff[aKey] = bValue;
                } else if (isVhook(bValue)) {
                     diff = diff || {};
                     diff[aKey] = bValue;
                } else {
                    var objectDiff = diffProps(aValue, bValue);
                    if (objectDiff) {
                        diff = diff || {};
                        diff[aKey] = objectDiff;
                    }
                }
            } else {
                diff = diff || {};
                diff[aKey] = bValue;
            }
        }

        for (var bKey in b) {
            if (!(bKey in a)) {
                diff = diff || {};
                diff[bKey] = b[bKey];
            }
        }

        return diff
    }

    function getPrototype$1(value) {
      if (Object.getPrototypeOf) {
        return Object.getPrototypeOf(value)
      } else if (value.__proto__) {
        return value.__proto__
      } else if (value.constructor) {
        return value.constructor.prototype
      }
    }

    var diff_1$1 = diff;

    function diff(a, b) {
        var patch = { a: a };
        walk(a, b, patch, 0);
        return patch
    }

    function walk(a, b, patch, index) {
        if (a === b) {
            return
        }

        var apply = patch[index];
        var applyClear = false;

        if (isThunk_1(a) || isThunk_1(b)) {
            thunks(a, b, patch, index);
        } else if (b == null) {

            // If a is a widget we will add a remove patch for it
            // Otherwise any child widgets/hooks must be destroyed.
            // This prevents adding two remove patches for a widget.
            if (!isWidget_1(a)) {
                clearState(a, patch, index);
                apply = patch[index];
            }

            apply = appendPatch(apply, new vpatch(vpatch.REMOVE, a, b));
        } else if (isVnode(b)) {
            if (isVnode(a)) {
                if (a.tagName === b.tagName &&
                    a.namespace === b.namespace &&
                    a.key === b.key) {
                    var propsPatch = diffProps_1(a.properties, b.properties);
                    if (propsPatch) {
                        apply = appendPatch(apply,
                            new vpatch(vpatch.PROPS, a, propsPatch));
                    }
                    apply = diffChildren(a, b, patch, apply, index);
                } else {
                    apply = appendPatch(apply, new vpatch(vpatch.VNODE, a, b));
                    applyClear = true;
                }
            } else {
                apply = appendPatch(apply, new vpatch(vpatch.VNODE, a, b));
                applyClear = true;
            }
        } else if (isVtext(b)) {
            if (!isVtext(a)) {
                apply = appendPatch(apply, new vpatch(vpatch.VTEXT, a, b));
                applyClear = true;
            } else if (a.text !== b.text) {
                apply = appendPatch(apply, new vpatch(vpatch.VTEXT, a, b));
            }
        } else if (isWidget_1(b)) {
            if (!isWidget_1(a)) {
                applyClear = true;
            }

            apply = appendPatch(apply, new vpatch(vpatch.WIDGET, a, b));
        }

        if (apply) {
            patch[index] = apply;
        }

        if (applyClear) {
            clearState(a, patch, index);
        }
    }

    function diffChildren(a, b, patch, apply, index) {
        var aChildren = a.children;
        var orderedSet = reorder(aChildren, b.children);
        var bChildren = orderedSet.children;

        var aLen = aChildren.length;
        var bLen = bChildren.length;
        var len = aLen > bLen ? aLen : bLen;

        for (var i = 0; i < len; i++) {
            var leftNode = aChildren[i];
            var rightNode = bChildren[i];
            index += 1;

            if (!leftNode) {
                if (rightNode) {
                    // Excess nodes in b need to be added
                    apply = appendPatch(apply,
                        new vpatch(vpatch.INSERT, null, rightNode));
                }
            } else {
                walk(leftNode, rightNode, patch, index);
            }

            if (isVnode(leftNode) && leftNode.count) {
                index += leftNode.count;
            }
        }

        if (orderedSet.moves) {
            // Reorder nodes last
            apply = appendPatch(apply, new vpatch(
                vpatch.ORDER,
                a,
                orderedSet.moves
            ));
        }

        return apply
    }

    function clearState(vNode, patch, index) {
        // TODO: Make this a single walk, not two
        unhook(vNode, patch, index);
        destroyWidgets(vNode, patch, index);
    }

    // Patch records for all destroyed widgets must be added because we need
    // a DOM node reference for the destroy function
    function destroyWidgets(vNode, patch, index) {
        if (isWidget_1(vNode)) {
            if (typeof vNode.destroy === "function") {
                patch[index] = appendPatch(
                    patch[index],
                    new vpatch(vpatch.REMOVE, vNode, null)
                );
            }
        } else if (isVnode(vNode) && (vNode.hasWidgets || vNode.hasThunks)) {
            var children = vNode.children;
            var len = children.length;
            for (var i = 0; i < len; i++) {
                var child = children[i];
                index += 1;

                destroyWidgets(child, patch, index);

                if (isVnode(child) && child.count) {
                    index += child.count;
                }
            }
        } else if (isThunk_1(vNode)) {
            thunks(vNode, null, patch, index);
        }
    }

    // Create a sub-patch for thunks
    function thunks(a, b, patch, index) {
        var nodes = handleThunk_1(a, b);
        var thunkPatch = diff(nodes.a, nodes.b);
        if (hasPatches(thunkPatch)) {
            patch[index] = new vpatch(vpatch.THUNK, null, thunkPatch);
        }
    }

    function hasPatches(patch) {
        for (var index in patch) {
            if (index !== "a") {
                return true
            }
        }

        return false
    }

    // Execute hooks when two nodes are identical
    function unhook(vNode, patch, index) {
        if (isVnode(vNode)) {
            if (vNode.hooks) {
                patch[index] = appendPatch(
                    patch[index],
                    new vpatch(
                        vpatch.PROPS,
                        vNode,
                        undefinedKeys(vNode.hooks)
                    )
                );
            }

            if (vNode.descendantHooks || vNode.hasThunks) {
                var children = vNode.children;
                var len = children.length;
                for (var i = 0; i < len; i++) {
                    var child = children[i];
                    index += 1;

                    unhook(child, patch, index);

                    if (isVnode(child) && child.count) {
                        index += child.count;
                    }
                }
            }
        } else if (isThunk_1(vNode)) {
            thunks(vNode, null, patch, index);
        }
    }

    function undefinedKeys(obj) {
        var result = {};

        for (var key in obj) {
            result[key] = undefined;
        }

        return result
    }

    // List diff, naive left to right reordering
    function reorder(aChildren, bChildren) {
        // O(M) time, O(M) memory
        var bChildIndex = keyIndex(bChildren);
        var bKeys = bChildIndex.keys;
        var bFree = bChildIndex.free;

        if (bFree.length === bChildren.length) {
            return {
                children: bChildren,
                moves: null
            }
        }

        // O(N) time, O(N) memory
        var aChildIndex = keyIndex(aChildren);
        var aKeys = aChildIndex.keys;
        var aFree = aChildIndex.free;

        if (aFree.length === aChildren.length) {
            return {
                children: bChildren,
                moves: null
            }
        }

        // O(MAX(N, M)) memory
        var newChildren = [];

        var freeIndex = 0;
        var freeCount = bFree.length;
        var deletedItems = 0;

        // Iterate through a and match a node in b
        // O(N) time,
        for (var i = 0 ; i < aChildren.length; i++) {
            var aItem = aChildren[i];
            var itemIndex;

            if (aItem.key) {
                if (bKeys.hasOwnProperty(aItem.key)) {
                    // Match up the old keys
                    itemIndex = bKeys[aItem.key];
                    newChildren.push(bChildren[itemIndex]);

                } else {
                    // Remove old keyed items
                    itemIndex = i - deletedItems++;
                    newChildren.push(null);
                }
            } else {
                // Match the item in a with the next free item in b
                if (freeIndex < freeCount) {
                    itemIndex = bFree[freeIndex++];
                    newChildren.push(bChildren[itemIndex]);
                } else {
                    // There are no free items in b to match with
                    // the free items in a, so the extra free nodes
                    // are deleted.
                    itemIndex = i - deletedItems++;
                    newChildren.push(null);
                }
            }
        }

        var lastFreeIndex = freeIndex >= bFree.length ?
            bChildren.length :
            bFree[freeIndex];

        // Iterate through b and append any new keys
        // O(M) time
        for (var j = 0; j < bChildren.length; j++) {
            var newItem = bChildren[j];

            if (newItem.key) {
                if (!aKeys.hasOwnProperty(newItem.key)) {
                    // Add any new keyed items
                    // We are adding new items to the end and then sorting them
                    // in place. In future we should insert new items in place.
                    newChildren.push(newItem);
                }
            } else if (j >= lastFreeIndex) {
                // Add any leftover non-keyed items
                newChildren.push(newItem);
            }
        }

        var simulate = newChildren.slice();
        var simulateIndex = 0;
        var removes = [];
        var inserts = [];
        var simulateItem;

        for (var k = 0; k < bChildren.length;) {
            var wantedItem = bChildren[k];
            simulateItem = simulate[simulateIndex];

            // remove items
            while (simulateItem === null && simulate.length) {
                removes.push(remove(simulate, simulateIndex, null));
                simulateItem = simulate[simulateIndex];
            }

            if (!simulateItem || simulateItem.key !== wantedItem.key) {
                // if we need a key in this position...
                if (wantedItem.key) {
                    if (simulateItem && simulateItem.key) {
                        // if an insert doesn't put this key in place, it needs to move
                        if (bKeys[simulateItem.key] !== k + 1) {
                            removes.push(remove(simulate, simulateIndex, simulateItem.key));
                            simulateItem = simulate[simulateIndex];
                            // if the remove didn't put the wanted item in place, we need to insert it
                            if (!simulateItem || simulateItem.key !== wantedItem.key) {
                                inserts.push({key: wantedItem.key, to: k});
                            }
                            // items are matching, so skip ahead
                            else {
                                simulateIndex++;
                            }
                        }
                        else {
                            inserts.push({key: wantedItem.key, to: k});
                        }
                    }
                    else {
                        inserts.push({key: wantedItem.key, to: k});
                    }
                    k++;
                }
                // a key in simulate has no matching wanted key, remove it
                else if (simulateItem && simulateItem.key) {
                    removes.push(remove(simulate, simulateIndex, simulateItem.key));
                }
            }
            else {
                simulateIndex++;
                k++;
            }
        }

        // remove all the remaining nodes from simulate
        while(simulateIndex < simulate.length) {
            simulateItem = simulate[simulateIndex];
            removes.push(remove(simulate, simulateIndex, simulateItem && simulateItem.key));
        }

        // If the only moves we have are deletes then we can just
        // let the delete patch remove these items.
        if (removes.length === deletedItems && !inserts.length) {
            return {
                children: newChildren,
                moves: null
            }
        }

        return {
            children: newChildren,
            moves: {
                removes: removes,
                inserts: inserts
            }
        }
    }

    function remove(arr, index, key) {
        arr.splice(index, 1);

        return {
            from: index,
            key: key
        }
    }

    function keyIndex(children) {
        var keys = {};
        var free = [];
        var length = children.length;

        for (var i = 0; i < length; i++) {
            var child = children[i];

            if (child.key) {
                keys[child.key] = i;
            } else {
                free.push(i);
            }
        }

        return {
            keys: keys,     // A hash of key name to index
            free: free      // An array of unkeyed item indices
        }
    }

    function appendPatch(apply, patch) {
        if (apply) {
            if (xIsArray(apply)) {
                apply.push(patch);
            } else {
                apply = [apply, patch];
            }

            return apply
        } else {
            return patch
        }
    }

    var diff_1 = diff_1$1;

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function getAugmentedNamespace(n) {
        if (n.__esModule) return n;
        var a = Object.defineProperty({}, '__esModule', {value: true});
        Object.keys(n).forEach(function (k) {
                var d = Object.getOwnPropertyDescriptor(n, k);
                Object.defineProperty(a, k, d.get ? d : {
                        enumerable: true,
                        get: function () {
                                return n[k];
                        }
                });
        });
        return a;
    }

    function createCommonjsModule(fn) {
      var module = { exports: {} };
        return fn(module, module.exports), module.exports;
    }

    function commonjsRequire (target) {
        throw new Error('Could not dynamically require "' + target + '". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
    }

    var slice = Array.prototype.slice;

    var domWalk = iterativelyWalk;

    function iterativelyWalk(nodes, cb) {
        if (!('length' in nodes)) {
            nodes = [nodes];
        }
        
        nodes = slice.call(nodes);

        while(nodes.length) {
            var node = nodes.shift(),
                ret = cb(node);

            if (ret) {
                return ret
            }

            if (node.childNodes && node.childNodes.length) {
                nodes = slice.call(node.childNodes).concat(nodes);
            }
        }
    }

    var domComment = Comment;

    function Comment(data, owner) {
        if (!(this instanceof Comment)) {
            return new Comment(data, owner)
        }

        this.data = data;
        this.nodeValue = data;
        this.length = data.length;
        this.ownerDocument = owner || null;
    }

    Comment.prototype.nodeType = 8;
    Comment.prototype.nodeName = "#comment";

    Comment.prototype.toString = function _Comment_toString() {
        return "[object Comment]"
    };

    var domText = DOMText;

    function DOMText(value, owner) {
        if (!(this instanceof DOMText)) {
            return new DOMText(value)
        }

        this.data = value || "";
        this.length = this.data.length;
        this.ownerDocument = owner || null;
    }

    DOMText.prototype.type = "DOMTextNode";
    DOMText.prototype.nodeType = 3;
    DOMText.prototype.nodeName = "#text";

    DOMText.prototype.toString = function _Text_toString() {
        return this.data
    };

    DOMText.prototype.replaceData = function replaceData(index, length, value) {
        var current = this.data;
        var left = current.substring(0, index);
        var right = current.substring(index + length, current.length);
        this.data = left + value + right;
        this.length = this.data.length;
    };

    var dispatchEvent_1 = dispatchEvent;

    function dispatchEvent(ev) {
        var elem = this;
        var type = ev.type;

        if (!ev.target) {
            ev.target = elem;
        }

        if (!elem.listeners) {
            elem.listeners = {};
        }

        var listeners = elem.listeners[type];

        if (listeners) {
            return listeners.forEach(function (listener) {
                ev.currentTarget = elem;
                if (typeof listener === 'function') {
                    listener(ev);
                } else {
                    listener.handleEvent(ev);
                }
            })
        }

        if (elem.parentNode) {
            elem.parentNode.dispatchEvent(ev);
        }
    }

    var addEventListener_1 = addEventListener;

    function addEventListener(type, listener) {
        var elem = this;

        if (!elem.listeners) {
            elem.listeners = {};
        }

        if (!elem.listeners[type]) {
            elem.listeners[type] = [];
        }

        if (elem.listeners[type].indexOf(listener) === -1) {
            elem.listeners[type].push(listener);
        }
    }

    var removeEventListener_1 = removeEventListener;

    function removeEventListener(type, listener) {
        var elem = this;

        if (!elem.listeners) {
            return
        }

        if (!elem.listeners[type]) {
            return
        }

        var list = elem.listeners[type];
        var index = list.indexOf(listener);
        if (index !== -1) {
            list.splice(index, 1);
        }
    }

    var serialize = serializeNode;

    var voidElements = ["area","base","br","col","embed","hr","img","input","keygen","link","menuitem","meta","param","source","track","wbr"];

    function serializeNode(node) {
        switch (node.nodeType) {
            case 3:
                return escapeText(node.data)
            case 8:
                return "<!--" + node.data + "-->"
            default:
                return serializeElement(node)
        }
    }

    function serializeElement(elem) {
        var strings = [];

        var tagname = elem.tagName;

        if (elem.namespaceURI === "http://www.w3.org/1999/xhtml") {
            tagname = tagname.toLowerCase();
        }

        strings.push("<" + tagname + properties(elem) + datasetify(elem));

        if (voidElements.indexOf(tagname) > -1) {
            strings.push(" />");
        } else {
            strings.push(">");

            if (elem.childNodes.length) {
                strings.push.apply(strings, elem.childNodes.map(serializeNode));
            } else if (elem.textContent || elem.innerText) {
                strings.push(escapeText(elem.textContent || elem.innerText));
            } else if (elem.innerHTML) {
                strings.push(elem.innerHTML);
            }

            strings.push("</" + tagname + ">");
        }

        return strings.join("")
    }

    function isProperty(elem, key) {
        var type = typeof elem[key];

        if (key === "style" && Object.keys(elem.style).length > 0) {
          return true
        }

        return elem.hasOwnProperty(key) &&
            (type === "string" || type === "boolean" || type === "number") &&
            key !== "nodeName" && key !== "className" && key !== "tagName" &&
            key !== "textContent" && key !== "innerText" && key !== "namespaceURI" &&  key !== "innerHTML"
    }

    function stylify(styles) {
        if (typeof styles === 'string') return styles
        var attr = "";
        Object.keys(styles).forEach(function (key) {
            var value = styles[key];
            key = key.replace(/[A-Z]/g, function(c) {
                return "-" + c.toLowerCase();
            });
            attr += key + ":" + value + ";";
        });
        return attr
    }

    function datasetify(elem) {
        var ds = elem.dataset;
        var props = [];

        for (var key in ds) {
            props.push({ name: "data-" + key, value: ds[key] });
        }

        return props.length ? stringify(props) : ""
    }

    function stringify(list) {
        var attributes = [];
        list.forEach(function (tuple) {
            var name = tuple.name;
            var value = tuple.value;

            if (name === "style") {
                value = stylify(value);
            }

            attributes.push(name + "=" + "\"" + escapeAttributeValue(value) + "\"");
        });

        return attributes.length ? " " + attributes.join(" ") : ""
    }

    function properties(elem) {
        var props = [];
        for (var key in elem) {
            if (isProperty(elem, key)) {
                props.push({ name: key, value: elem[key] });
            }
        }

        for (var ns in elem._attributes) {
          for (var attribute in elem._attributes[ns]) {
            var prop = elem._attributes[ns][attribute];
            var name = (prop.prefix ? prop.prefix + ":" : "") + attribute;
            props.push({ name: name, value: prop.value });
          }
        }

        if (elem.className) {
            props.push({ name: "class", value: elem.className });
        }

        return props.length ? stringify(props) : ""
    }

    function escapeText(s) {
        var str = '';

        if (typeof(s) === 'string') { 
            str = s; 
        } else if (s) {
            str = s.toString();
        }

        return str
            .replace(/&/g, "&amp;")
            .replace(/</g, "&lt;")
            .replace(/>/g, "&gt;")
    }

    function escapeAttributeValue(str) {
        return escapeText(str).replace(/"/g, "&quot;")
    }

    var htmlns = "http://www.w3.org/1999/xhtml";

    var domElement = DOMElement;

    function DOMElement(tagName, owner, namespace) {
        if (!(this instanceof DOMElement)) {
            return new DOMElement(tagName)
        }

        var ns = namespace === undefined ? htmlns : (namespace || null);

        this.tagName = ns === htmlns ? String(tagName).toUpperCase() : tagName;
        this.nodeName = this.tagName;
        this.className = "";
        this.dataset = {};
        this.childNodes = [];
        this.parentNode = null;
        this.style = {};
        this.ownerDocument = owner || null;
        this.namespaceURI = ns;
        this._attributes = {};

        if (this.tagName === 'INPUT') {
          this.type = 'text';
        }
    }

    DOMElement.prototype.type = "DOMElement";
    DOMElement.prototype.nodeType = 1;

    DOMElement.prototype.appendChild = function _Element_appendChild(child) {
        if (child.parentNode) {
            child.parentNode.removeChild(child);
        }

        this.childNodes.push(child);
        child.parentNode = this;

        return child
    };

    DOMElement.prototype.replaceChild =
        function _Element_replaceChild(elem, needle) {
            // TODO: Throw NotFoundError if needle.parentNode !== this

            if (elem.parentNode) {
                elem.parentNode.removeChild(elem);
            }

            var index = this.childNodes.indexOf(needle);

            needle.parentNode = null;
            this.childNodes[index] = elem;
            elem.parentNode = this;

            return needle
        };

    DOMElement.prototype.removeChild = function _Element_removeChild(elem) {
        // TODO: Throw NotFoundError if elem.parentNode !== this

        var index = this.childNodes.indexOf(elem);
        this.childNodes.splice(index, 1);

        elem.parentNode = null;
        return elem
    };

    DOMElement.prototype.insertBefore =
        function _Element_insertBefore(elem, needle) {
            // TODO: Throw NotFoundError if referenceElement is a dom node
            // and parentNode !== this

            if (elem.parentNode) {
                elem.parentNode.removeChild(elem);
            }

            var index = needle === null || needle === undefined ?
                -1 :
                this.childNodes.indexOf(needle);

            if (index > -1) {
                this.childNodes.splice(index, 0, elem);
            } else {
                this.childNodes.push(elem);
            }

            elem.parentNode = this;
            return elem
        };

    DOMElement.prototype.setAttributeNS =
        function _Element_setAttributeNS(namespace, name, value) {
            var prefix = null;
            var localName = name;
            var colonPosition = name.indexOf(":");
            if (colonPosition > -1) {
                prefix = name.substr(0, colonPosition);
                localName = name.substr(colonPosition + 1);
            }
            if (this.tagName === 'INPUT' && name === 'type') {
              this.type = value;
            }
            else {
              var attributes = this._attributes[namespace] || (this._attributes[namespace] = {});
              attributes[localName] = {value: value, prefix: prefix};
            }
        };

    DOMElement.prototype.getAttributeNS =
        function _Element_getAttributeNS(namespace, name) {
            var attributes = this._attributes[namespace];
            var value = attributes && attributes[name] && attributes[name].value;
            if (this.tagName === 'INPUT' && name === 'type') {
              return this.type;
            }
            if (typeof value !== "string") {
                return null
            }
            return value
        };

    DOMElement.prototype.removeAttributeNS =
        function _Element_removeAttributeNS(namespace, name) {
            var attributes = this._attributes[namespace];
            if (attributes) {
                delete attributes[name];
            }
        };

    DOMElement.prototype.hasAttributeNS =
        function _Element_hasAttributeNS(namespace, name) {
            var attributes = this._attributes[namespace];
            return !!attributes && name in attributes;
        };

    DOMElement.prototype.setAttribute = function _Element_setAttribute(name, value) {
        return this.setAttributeNS(null, name, value)
    };

    DOMElement.prototype.getAttribute = function _Element_getAttribute(name) {
        return this.getAttributeNS(null, name)
    };

    DOMElement.prototype.removeAttribute = function _Element_removeAttribute(name) {
        return this.removeAttributeNS(null, name)
    };

    DOMElement.prototype.hasAttribute = function _Element_hasAttribute(name) {
        return this.hasAttributeNS(null, name)
    };

    DOMElement.prototype.removeEventListener = removeEventListener_1;
    DOMElement.prototype.addEventListener = addEventListener_1;
    DOMElement.prototype.dispatchEvent = dispatchEvent_1;

    // Un-implemented
    DOMElement.prototype.focus = function _Element_focus() {
        return void 0
    };

    DOMElement.prototype.toString = function _Element_toString() {
        return serialize(this)
    };

    DOMElement.prototype.getElementsByClassName = function _Element_getElementsByClassName(classNames) {
        var classes = classNames.split(" ");
        var elems = [];

        domWalk(this, function (node) {
            if (node.nodeType === 1) {
                var nodeClassName = node.className || "";
                var nodeClasses = nodeClassName.split(" ");

                if (classes.every(function (item) {
                    return nodeClasses.indexOf(item) !== -1
                })) {
                    elems.push(node);
                }
            }
        });

        return elems
    };

    DOMElement.prototype.getElementsByTagName = function _Element_getElementsByTagName(tagName) {
        tagName = tagName.toLowerCase();
        var elems = [];

        domWalk(this.childNodes, function (node) {
            if (node.nodeType === 1 && (tagName === '*' || node.tagName.toLowerCase() === tagName)) {
                elems.push(node);
            }
        });

        return elems
    };

    DOMElement.prototype.contains = function _Element_contains(element) {
        return domWalk(this, function (node) {
            return element === node
        }) || false
    };

    var domFragment = DocumentFragment;

    function DocumentFragment(owner) {
        if (!(this instanceof DocumentFragment)) {
            return new DocumentFragment()
        }

        this.childNodes = [];
        this.parentNode = null;
        this.ownerDocument = owner || null;
    }

    DocumentFragment.prototype.type = "DocumentFragment";
    DocumentFragment.prototype.nodeType = 11;
    DocumentFragment.prototype.nodeName = "#document-fragment";

    DocumentFragment.prototype.appendChild  = domElement.prototype.appendChild;
    DocumentFragment.prototype.replaceChild = domElement.prototype.replaceChild;
    DocumentFragment.prototype.removeChild  = domElement.prototype.removeChild;

    DocumentFragment.prototype.toString =
        function _DocumentFragment_toString() {
            return this.childNodes.map(function (node) {
                return String(node)
            }).join("")
        };

    var event = Event;

    function Event(family) {}

    Event.prototype.initEvent = function _Event_initEvent(type, bubbles, cancelable) {
        this.type = type;
        this.bubbles = bubbles;
        this.cancelable = cancelable;
    };

    Event.prototype.preventDefault = function _Event_preventDefault() {
        
    };

    var document$1 = Document;

    function Document() {
        if (!(this instanceof Document)) {
            return new Document();
        }

        this.head = this.createElement("head");
        this.body = this.createElement("body");
        this.documentElement = this.createElement("html");
        this.documentElement.appendChild(this.head);
        this.documentElement.appendChild(this.body);
        this.childNodes = [this.documentElement];
        this.nodeType = 9;
    }

    var proto = Document.prototype;
    proto.createTextNode = function createTextNode(value) {
        return new domText(value, this)
    };

    proto.createElementNS = function createElementNS(namespace, tagName) {
        var ns = namespace === null ? null : String(namespace);
        return new domElement(tagName, this, ns)
    };

    proto.createElement = function createElement(tagName) {
        return new domElement(tagName, this)
    };

    proto.createDocumentFragment = function createDocumentFragment() {
        return new domFragment(this)
    };

    proto.createEvent = function createEvent(family) {
        return new event(family)
    };

    proto.createComment = function createComment(data) {
        return new domComment(data, this)
    };

    proto.getElementById = function getElementById(id) {
        id = String(id);

        var result = domWalk(this.childNodes, function (node) {
            if (String(node.id) === id) {
                return node
            }
        });

        return result || null
    };

    proto.getElementsByClassName = domElement.prototype.getElementsByClassName;
    proto.getElementsByTagName = domElement.prototype.getElementsByTagName;
    proto.contains = domElement.prototype.contains;

    proto.removeEventListener = removeEventListener_1;
    proto.addEventListener = addEventListener_1;
    proto.dispatchEvent = dispatchEvent_1;

    var minDocument = new document$1();

    var topLevel = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal :
        typeof window !== 'undefined' ? window : {};


    var doccy;

    if (typeof document !== 'undefined') {
        doccy = document;
    } else {
        doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];

        if (!doccy) {
            doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDocument;
        }
    }

    var document_1 = doccy;

    var applyProperties_1 = applyProperties;

    function applyProperties(node, props, previous) {
        for (var propName in props) {
            var propValue = props[propName];

            if (propValue === undefined) {
                removeProperty(node, propName, propValue, previous);
            } else if (isVhook(propValue)) {
                removeProperty(node, propName, propValue, previous);
                if (propValue.hook) {
                    propValue.hook(node,
                        propName,
                        previous ? previous[propName] : undefined);
                }
            } else {
                if (isObject(propValue)) {
                    patchObject(node, props, previous, propName, propValue);
                } else {
                    node[propName] = propValue;
                }
            }
        }
    }

    function removeProperty(node, propName, propValue, previous) {
        if (previous) {
            var previousValue = previous[propName];

            if (!isVhook(previousValue)) {
                if (propName === "attributes") {
                    for (var attrName in previousValue) {
                        node.removeAttribute(attrName);
                    }
                } else if (propName === "style") {
                    for (var i in previousValue) {
                        node.style[i] = "";
                    }
                } else if (typeof previousValue === "string") {
                    node[propName] = "";
                } else {
                    node[propName] = null;
                }
            } else if (previousValue.unhook) {
                previousValue.unhook(node, propName, propValue);
            }
        }
    }

    function patchObject(node, props, previous, propName, propValue) {
        var previousValue = previous ? previous[propName] : undefined;

        // Set attributes
        if (propName === "attributes") {
            for (var attrName in propValue) {
                var attrValue = propValue[attrName];

                if (attrValue === undefined) {
                    node.removeAttribute(attrName);
                } else {
                    node.setAttribute(attrName, attrValue);
                }
            }

            return
        }

        if(previousValue && isObject(previousValue) &&
            getPrototype(previousValue) !== getPrototype(propValue)) {
            node[propName] = propValue;
            return
        }

        if (!isObject(node[propName])) {
            node[propName] = {};
        }

        var replacer = propName === "style" ? "" : undefined;

        for (var k in propValue) {
            var value = propValue[k];
            node[propName][k] = (value === undefined) ? replacer : value;
        }
    }

    function getPrototype(value) {
        if (Object.getPrototypeOf) {
            return Object.getPrototypeOf(value)
        } else if (value.__proto__) {
            return value.__proto__
        } else if (value.constructor) {
            return value.constructor.prototype
        }
    }

    var createElement_1$1 = createElement;

    function createElement(vnode, opts) {
        var doc = opts ? opts.document || document_1 : document_1;
        var warn = opts ? opts.warn : null;

        vnode = handleThunk_1(vnode).a;

        if (isWidget_1(vnode)) {
            return vnode.init()
        } else if (isVtext(vnode)) {
            return doc.createTextNode(vnode.text)
        } else if (!isVnode(vnode)) {
            if (warn) {
                warn("Item is not a valid virtual dom node", vnode);
            }
            return null
        }

        var node = (vnode.namespace === null) ?
            doc.createElement(vnode.tagName) :
            doc.createElementNS(vnode.namespace, vnode.tagName);

        var props = vnode.properties;
        applyProperties_1(node, props);

        var children = vnode.children;

        for (var i = 0; i < children.length; i++) {
            var childNode = createElement(children[i], opts);
            if (childNode) {
                node.appendChild(childNode);
            }
        }

        return node
    }

    // Maps a virtual DOM tree onto a real DOM tree in an efficient manner.
    // We don't want to read all of the DOM nodes in the tree so we use
    // the in-order tree indexing to eliminate recursion down certain branches.
    // We only recurse into a DOM node if we know that it contains a child of
    // interest.

    var noChild = {};

    var domIndex_1 = domIndex;

    function domIndex(rootNode, tree, indices, nodes) {
        if (!indices || indices.length === 0) {
            return {}
        } else {
            indices.sort(ascending);
            return recurse(rootNode, tree, indices, nodes, 0)
        }
    }

    function recurse(rootNode, tree, indices, nodes, rootIndex) {
        nodes = nodes || {};


        if (rootNode) {
            if (indexInRange(indices, rootIndex, rootIndex)) {
                nodes[rootIndex] = rootNode;
            }

            var vChildren = tree.children;

            if (vChildren) {

                var childNodes = rootNode.childNodes;

                for (var i = 0; i < tree.children.length; i++) {
                    rootIndex += 1;

                    var vChild = vChildren[i] || noChild;
                    var nextIndex = rootIndex + (vChild.count || 0);

                    // skip recursion down the tree if there are no nodes down here
                    if (indexInRange(indices, rootIndex, nextIndex)) {
                        recurse(childNodes[i], vChild, indices, nodes, rootIndex);
                    }

                    rootIndex = nextIndex;
                }
            }
        }

        return nodes
    }

    // Binary search for an index in the interval [left, right]
    function indexInRange(indices, left, right) {
        if (indices.length === 0) {
            return false
        }

        var minIndex = 0;
        var maxIndex = indices.length - 1;
        var currentIndex;
        var currentItem;

        while (minIndex <= maxIndex) {
            currentIndex = ((maxIndex + minIndex) / 2) >> 0;
            currentItem = indices[currentIndex];

            if (minIndex === maxIndex) {
                return currentItem >= left && currentItem <= right
            } else if (currentItem < left) {
                minIndex = currentIndex + 1;
            } else  if (currentItem > right) {
                maxIndex = currentIndex - 1;
            } else {
                return true
            }
        }

        return false;
    }

    function ascending(a, b) {
        return a > b ? 1 : -1
    }

    var updateWidget_1 = updateWidget;

    function updateWidget(a, b) {
        if (isWidget_1(a) && isWidget_1(b)) {
            if ("name" in a && "name" in b) {
                return a.id === b.id
            } else {
                return a.init === b.init
            }
        }

        return false
    }

    var patchOp = applyPatch$1;

    function applyPatch$1(vpatch$1, domNode, renderOptions) {
        var type = vpatch$1.type;
        var vNode = vpatch$1.vNode;
        var patch = vpatch$1.patch;

        switch (type) {
            case vpatch.REMOVE:
                return removeNode$1(domNode, vNode)
            case vpatch.INSERT:
                return insertNode$1(domNode, patch, renderOptions)
            case vpatch.VTEXT:
                return stringPatch(domNode, vNode, patch, renderOptions)
            case vpatch.WIDGET:
                return widgetPatch(domNode, vNode, patch, renderOptions)
            case vpatch.VNODE:
                return vNodePatch(domNode, vNode, patch, renderOptions)
            case vpatch.ORDER:
                reorderChildren(domNode, patch);
                return domNode
            case vpatch.PROPS:
                applyProperties_1(domNode, patch, vNode.properties);
                return domNode
            case vpatch.THUNK:
                return replaceRoot(domNode,
                    renderOptions.patch(domNode, patch, renderOptions))
            default:
                return domNode
        }
    }

    function removeNode$1(domNode, vNode) {
        var parentNode = domNode.parentNode;

        if (parentNode) {
            parentNode.removeChild(domNode);
        }

        destroyWidget(domNode, vNode);

        return null
    }

    function insertNode$1(parentNode, vNode, renderOptions) {
        var newNode = renderOptions.render(vNode, renderOptions);

        if (parentNode) {
            parentNode.appendChild(newNode);
        }

        return parentNode
    }

    function stringPatch(domNode, leftVNode, vText, renderOptions) {
        var newNode;

        if (domNode.nodeType === 3) {
            domNode.replaceData(0, domNode.length, vText.text);
            newNode = domNode;
        } else {
            var parentNode = domNode.parentNode;
            newNode = renderOptions.render(vText, renderOptions);

            if (parentNode && newNode !== domNode) {
                parentNode.replaceChild(newNode, domNode);
            }
        }

        return newNode
    }

    function widgetPatch(domNode, leftVNode, widget, renderOptions) {
        var updating = updateWidget_1(leftVNode, widget);
        var newNode;

        if (updating) {
            newNode = widget.update(leftVNode, domNode) || domNode;
        } else {
            newNode = renderOptions.render(widget, renderOptions);
        }

        var parentNode = domNode.parentNode;

        if (parentNode && newNode !== domNode) {
            parentNode.replaceChild(newNode, domNode);
        }

        if (!updating) {
            destroyWidget(domNode, leftVNode);
        }

        return newNode
    }

    function vNodePatch(domNode, leftVNode, vNode, renderOptions) {
        var parentNode = domNode.parentNode;
        var newNode = renderOptions.render(vNode, renderOptions);

        if (parentNode && newNode !== domNode) {
            parentNode.replaceChild(newNode, domNode);
        }

        return newNode
    }

    function destroyWidget(domNode, w) {
        if (typeof w.destroy === "function" && isWidget_1(w)) {
            w.destroy(domNode);
        }
    }

    function reorderChildren(domNode, moves) {
        var childNodes = domNode.childNodes;
        var keyMap = {};
        var node;
        var remove;
        var insert;

        for (var i = 0; i < moves.removes.length; i++) {
            remove = moves.removes[i];
            node = childNodes[remove.from];
            if (remove.key) {
                keyMap[remove.key] = node;
            }
            domNode.removeChild(node);
        }

        var length = childNodes.length;
        for (var j = 0; j < moves.inserts.length; j++) {
            insert = moves.inserts[j];
            node = keyMap[insert.key];
            // this is the weirdest bug i've ever seen in webkit
            domNode.insertBefore(node, insert.to >= length++ ? null : childNodes[insert.to]);
        }
    }

    function replaceRoot(oldRoot, newRoot) {
        if (oldRoot && newRoot && oldRoot !== newRoot && oldRoot.parentNode) {
            oldRoot.parentNode.replaceChild(newRoot, oldRoot);
        }

        return newRoot;
    }

    var patch_1$1 = patch;

    function patch(rootNode, patches, renderOptions) {
        renderOptions = renderOptions || {};
        renderOptions.patch = renderOptions.patch && renderOptions.patch !== patch
            ? renderOptions.patch
            : patchRecursive;
        renderOptions.render = renderOptions.render || createElement_1$1;

        return renderOptions.patch(rootNode, patches, renderOptions)
    }

    function patchRecursive(rootNode, patches, renderOptions) {
        var indices = patchIndices(patches);

        if (indices.length === 0) {
            return rootNode
        }

        var index = domIndex_1(rootNode, patches.a, indices);
        var ownerDocument = rootNode.ownerDocument;

        if (!renderOptions.document && ownerDocument !== document_1) {
            renderOptions.document = ownerDocument;
        }

        for (var i = 0; i < indices.length; i++) {
            var nodeIndex = indices[i];
            rootNode = applyPatch(rootNode,
                index[nodeIndex],
                patches[nodeIndex],
                renderOptions);
        }

        return rootNode
    }

    function applyPatch(rootNode, domNode, patchList, renderOptions) {
        if (!domNode) {
            return rootNode
        }

        var newNode;

        if (xIsArray(patchList)) {
            for (var i = 0; i < patchList.length; i++) {
                newNode = patchOp(patchList[i], domNode, renderOptions);

                if (domNode === rootNode) {
                    rootNode = newNode;
                }
            }
        } else {
            newNode = patchOp(patchList, domNode, renderOptions);

            if (domNode === rootNode) {
                rootNode = newNode;
            }
        }

        return rootNode
    }

    function patchIndices(patches) {
        var indices = [];

        for (var key in patches) {
            if (key !== "a") {
                indices.push(Number(key));
            }
        }

        return indices
    }

    var patch_1 = patch_1$1;

    var vnode = VirtualNode;

    var noProperties = {};
    var noChildren = [];

    function VirtualNode(tagName, properties, children, key, namespace) {
        this.tagName = tagName;
        this.properties = properties || noProperties;
        this.children = children || noChildren;
        this.key = key != null ? String(key) : undefined;
        this.namespace = (typeof namespace === "string") ? namespace : null;

        var count = (children && children.length) || 0;
        var descendants = 0;
        var hasWidgets = false;
        var hasThunks = false;
        var descendantHooks = false;
        var hooks;

        for (var propName in properties) {
            if (properties.hasOwnProperty(propName)) {
                var property = properties[propName];
                if (isVhook(property) && property.unhook) {
                    if (!hooks) {
                        hooks = {};
                    }

                    hooks[propName] = property;
                }
            }
        }

        for (var i = 0; i < count; i++) {
            var child = children[i];
            if (isVnode(child)) {
                descendants += child.count || 0;

                if (!hasWidgets && child.hasWidgets) {
                    hasWidgets = true;
                }

                if (!hasThunks && child.hasThunks) {
                    hasThunks = true;
                }

                if (!descendantHooks && (child.hooks || child.descendantHooks)) {
                    descendantHooks = true;
                }
            } else if (!hasWidgets && isWidget_1(child)) {
                if (typeof child.destroy === "function") {
                    hasWidgets = true;
                }
            } else if (!hasThunks && isThunk_1(child)) {
                hasThunks = true;
            }
        }

        this.count = count + descendants;
        this.hasWidgets = hasWidgets;
        this.hasThunks = hasThunks;
        this.hooks = hooks;
        this.descendantHooks = descendantHooks;
    }

    VirtualNode.prototype.version = version;
    VirtualNode.prototype.type = "VirtualNode";

    var vtext = VirtualText;

    function VirtualText(text) {
        this.text = String(text);
    }

    VirtualText.prototype.version = version;
    VirtualText.prototype.type = "VirtualText";

    /*!
     * Cross-Browser Split 1.1.1
     * Copyright 2007-2012 Steven Levithan <stevenlevithan.com>
     * Available under the MIT License
     * ECMAScript compliant, uniform cross-browser split method
     */
    /**
     * Splits a string into an array of strings using a regex or string separator. Matches of the
     * separator are not included in the result array. However, if `separator` is a regex that contains
     * capturing groups, backreferences are spliced into the result each time `separator` is matched.
     * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
     * cross-browser.
     * @param {String} str String to split.
     * @param {RegExp|String} separator Regex or string to use for separating the string.
     * @param {Number} [limit] Maximum number of items to include in the result array.
     * @returns {Array} Array of substrings.
     * @example
     *
     * // Basic use
     * split('a b c d', ' ');
     * // -> ['a', 'b', 'c', 'd']
     *
     * // With limit
     * split('a b c d', ' ', 2);
     * // -> ['a', 'b']
     *
     * // Backreferences in result array
     * split('..word1 word2..', /([a-z]+)(\d+)/i);
     * // -> ['..', 'word', '1', ' ', 'word', '2', '..']
     */
    var browserSplit = (function split(undef) {

      var nativeSplit = String.prototype.split,
        compliantExecNpcg = /()??/.exec("")[1] === undef,
        // NPCG: nonparticipating capturing group
        self;

      self = function(str, separator, limit) {
        // If `separator` is not a regex, use `nativeSplit`
        if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
          return nativeSplit.call(str, separator, limit);
        }
        var output = [],
          flags = (separator.ignoreCase ? "i" : "") + (separator.multiline ? "m" : "") + (separator.extended ? "x" : "") + // Proposed for ES6
          (separator.sticky ? "y" : ""),
          // Firefox 3+
          lastLastIndex = 0,
          // Make `global` and avoid `lastIndex` issues by working with a copy
          separator = new RegExp(separator.source, flags + "g"),
          separator2, match, lastIndex, lastLength;
        str += ""; // Type-convert
        if (!compliantExecNpcg) {
          // Doesn't need flags gy, but they don't hurt
          separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags);
        }
        /* Values for `limit`, per the spec:
         * If undefined: 4294967295 // Math.pow(2, 32) - 1
         * If 0, Infinity, or NaN: 0
         * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
         * If negative number: 4294967296 - Math.floor(Math.abs(limit))
         * If other: Type-convert, then use the above rules
         */
        limit = limit === undef ? -1 >>> 0 : // Math.pow(2, 32) - 1
        limit >>> 0; // ToUint32(limit)
        while (match = separator.exec(str)) {
          // `separator.lastIndex` is not reliable cross-browser
          lastIndex = match.index + match[0].length;
          if (lastIndex > lastLastIndex) {
            output.push(str.slice(lastLastIndex, match.index));
            // Fix browsers whose `exec` methods don't consistently return `undefined` for
            // nonparticipating capturing groups
            if (!compliantExecNpcg && match.length > 1) {
              match[0].replace(separator2, function() {
                for (var i = 1; i < arguments.length - 2; i++) {
                  if (arguments[i] === undef) {
                    match[i] = undef;
                  }
                }
              });
            }
            if (match.length > 1 && match.index < str.length) {
              Array.prototype.push.apply(output, match.slice(1));
            }
            lastLength = match[0].length;
            lastLastIndex = lastIndex;
            if (output.length >= limit) {
              break;
            }
          }
          if (separator.lastIndex === match.index) {
            separator.lastIndex++; // Avoid an infinite loop
          }
        }
        if (lastLastIndex === str.length) {
          if (lastLength || !separator.test("")) {
            output.push("");
          }
        } else {
          output.push(str.slice(lastLastIndex));
        }
        return output.length > limit ? output.slice(0, limit) : output;
      };

      return self;
    })();

    var classIdSplit = /([\.#]?[a-zA-Z0-9\u007F-\uFFFF_:-]+)/;
    var notClassId = /^\.|#/;

    var parseTag_1 = parseTag;

    function parseTag(tag, props) {
        if (!tag) {
            return 'DIV';
        }

        var noId = !(props.hasOwnProperty('id'));

        var tagParts = browserSplit(tag, classIdSplit);
        var tagName = null;

        if (notClassId.test(tagParts[1])) {
            tagName = 'DIV';
        }

        var classes, part, type, i;

        for (i = 0; i < tagParts.length; i++) {
            part = tagParts[i];

            if (!part) {
                continue;
            }

            type = part.charAt(0);

            if (!tagName) {
                tagName = part;
            } else if (type === '.') {
                classes = classes || [];
                classes.push(part.substring(1, part.length));
            } else if (type === '#' && noId) {
                props.id = part.substring(1, part.length);
            }
        }

        if (classes) {
            if (props.className) {
                classes.push(props.className);
            }

            props.className = classes.join(' ');
        }

        return props.namespace ? tagName : tagName.toUpperCase();
    }

    var softSetHook = SoftSetHook;

    function SoftSetHook(value) {
        if (!(this instanceof SoftSetHook)) {
            return new SoftSetHook(value);
        }

        this.value = value;
    }

    SoftSetHook.prototype.hook = function (node, propertyName) {
        if (node[propertyName] !== this.value) {
            node[propertyName] = this.value;
        }
    };

    /*global window, global*/

    var root = typeof window !== 'undefined' ?
        window : typeof commonjsGlobal !== 'undefined' ?
        commonjsGlobal : {};

    var individual = Individual;

    function Individual(key, value) {
        if (key in root) {
            return root[key];
        }

        root[key] = value;

        return value;
    }

    var oneVersion = OneVersion;

    function OneVersion(moduleName, version, defaultValue) {
        var key = '__INDIVIDUAL_ONE_VERSION_' + moduleName;
        var enforceKey = key + '_ENFORCE_SINGLETON';

        var versionValue = individual(enforceKey, version);

        if (versionValue !== version) {
            throw new Error('Can only have one copy of ' +
                moduleName + '.\n' +
                'You already have version ' + versionValue +
                ' installed.\n' +
                'This means you cannot install version ' + version);
        }

        return individual(key, defaultValue);
    }

    var MY_VERSION = '7';
    oneVersion('ev-store', MY_VERSION);

    var hashKey = '__EV_STORE_KEY@' + MY_VERSION;

    var evStore = EvStore;

    function EvStore(elem) {
        var hash = elem[hashKey];

        if (!hash) {
            hash = elem[hashKey] = {};
        }

        return hash;
    }

    var evHook = EvHook;

    function EvHook(value) {
        if (!(this instanceof EvHook)) {
            return new EvHook(value);
        }

        this.value = value;
    }

    EvHook.prototype.hook = function (node, propertyName) {
        var es = evStore(node);
        var propName = propertyName.substr(3);

        es[propName] = this.value;
    };

    EvHook.prototype.unhook = function(node, propertyName) {
        var es = evStore(node);
        var propName = propertyName.substr(3);

        es[propName] = undefined;
    };

    var virtualHyperscript = h;

    function h(tagName, properties, children) {
        var childNodes = [];
        var tag, props, key, namespace;

        if (!children && isChildren(properties)) {
            children = properties;
            props = {};
        }

        props = props || properties || {};
        tag = parseTag_1(tagName, props);

        // support keys
        if (props.hasOwnProperty('key')) {
            key = props.key;
            props.key = undefined;
        }

        // support namespace
        if (props.hasOwnProperty('namespace')) {
            namespace = props.namespace;
            props.namespace = undefined;
        }

        // fix cursor bug
        if (tag === 'INPUT' &&
            !namespace &&
            props.hasOwnProperty('value') &&
            props.value !== undefined &&
            !isVhook(props.value)
        ) {
            props.value = softSetHook(props.value);
        }

        transformProperties(props);

        if (children !== undefined && children !== null) {
            addChild(children, childNodes, tag, props);
        }


        return new vnode(tag, props, childNodes, key, namespace);
    }

    function addChild(c, childNodes, tag, props) {
        if (typeof c === 'string') {
            childNodes.push(new vtext(c));
        } else if (typeof c === 'number') {
            childNodes.push(new vtext(String(c)));
        } else if (isChild(c)) {
            childNodes.push(c);
        } else if (xIsArray(c)) {
            for (var i = 0; i < c.length; i++) {
                addChild(c[i], childNodes, tag, props);
            }
        } else if (c === null || c === undefined) {
            return;
        } else {
            throw UnexpectedVirtualElement({
                foreignObject: c,
                parentVnode: {
                    tagName: tag,
                    properties: props
                }
            });
        }
    }

    function transformProperties(props) {
        for (var propName in props) {
            if (props.hasOwnProperty(propName)) {
                var value = props[propName];

                if (isVhook(value)) {
                    continue;
                }

                if (propName.substr(0, 3) === 'ev-') {
                    // add ev-foo support
                    props[propName] = evHook(value);
                }
            }
        }
    }

    function isChild(x) {
        return isVnode(x) || isVtext(x) || isWidget_1(x) || isThunk_1(x);
    }

    function isChildren(x) {
        return typeof x === 'string' || xIsArray(x) || isChild(x);
    }

    function UnexpectedVirtualElement(data) {
        var err = new Error();

        err.type = 'virtual-hyperscript.unexpected.virtual-element';
        err.message = 'Unexpected virtual child passed to h().\n' +
            'Expected a VNode / Vthunk / VWidget / string but:\n' +
            'got:\n' +
            errorString(data.foreignObject) +
            '.\n' +
            'The parent vnode is:\n' +
            errorString(data.parentVnode);
        err.foreignObject = data.foreignObject;
        err.parentVnode = data.parentVnode;

        return err;
    }

    function errorString(obj) {
        try {
            return JSON.stringify(obj, null, '    ');
        } catch (e) {
            return String(obj);
        }
    }

    var h_1 = virtualHyperscript;

    var createElement_1 = createElement_1$1;

    var virtualDom = {
        diff: diff_1,
        patch: patch_1,
        h: h_1,
        create: createElement_1,
        VNode: vnode,
        VText: vtext
    };

    class EventEmitter {
        constructor() { this._events = {}; }
        /**
         * Subscribe to an event by its name.
         * @param {string} type - The name of the event
         * to subscribe to.
         * @param {(event: T) => void} handler - The
         * handler called when the event occurs.
         */
        on(type, handler) {
            this._events[type] = this._events[type] || [];
            this._events[type].push(handler);
        }
        /**
         * Unsubscribe from an event by its name.
         * @param {string} type - The name of the event
         * to unsubscribe from.
         * @param {(event: T) => void} handler - The
         * handler to remove.
         */
        off(type, handler) {
            if (!type) {
                this._events = {};
                return;
            }
            if (this._listens(type)) {
                const index = this._events[type].indexOf(handler);
                if (index >= 0) {
                    this._events[type].splice(index, 1);
                }
                if (!this._events[type].length) {
                    delete this._events[type];
                }
            }
        }
        /**
         * @ignore
         */
        fire(type, event) {
            if (!this._listens(type)) {
                return;
            }
            for (const handler of this._events[type]) {
                handler(event);
            }
        }
        _listens(eventType) {
            return eventType in this._events;
        }
    }

    class SubscriptionHolder {
        constructor() {
            this._subscriptions = [];
        }
        push(subscription) {
            this._subscriptions.push(subscription);
        }
        unsubscribe() {
            for (const sub of this._subscriptions) {
                sub.unsubscribe();
            }
            this._subscriptions = [];
        }
    }

    class Component extends EventEmitter {
        constructor(name, container, navigator) {
            super();
            this._activated$ = new BehaviorSubject(false);
            this._configurationSubject$ = new Subject();
            this._activated = false;
            this._container = container;
            this._name = name;
            this._navigator = navigator;
            this._subscriptions = new SubscriptionHolder();
            this._configuration$ =
                this._configurationSubject$.pipe(startWith(this.defaultConfiguration), scan((conf, newConf) => {
                    for (let key in newConf) {
                        if (newConf.hasOwnProperty(key)) {
                            conf[key] = newConf[key];
                        }
                    }
                    return conf;
                }), publishReplay(1), refCount());
            this._configuration$.subscribe(() => { });
        }
        /**
         * Get activated.
         *
         * @returns {boolean} Value indicating if the component is
         * currently active.
         */
        get activated() {
            return this._activated;
        }
        /** @ignore */
        get activated$() {
            return this._activated$;
        }
        /**
         * Get default configuration.
         *
         * @returns {TConfiguration} Default configuration for component.
         */
        get defaultConfiguration() {
            return this._getDefaultConfiguration();
        }
        /** @ignore */
        get configuration$() {
            return this._configuration$;
        }
        /**
         * Get name.
         *
         * @description The name of the component. Used when interacting with the
         * component through the Viewer's API.
         */
        get name() {
            return this._name;
        }
        /** @ignore */
        activate(conf) {
            if (this._activated) {
                return;
            }
            if (conf !== undefined) {
                this._configurationSubject$.next(conf);
            }
            this._activated = true;
            this._activate();
            this._activated$.next(true);
        }
        /**
         * Configure the component.
         *
         * @param configuration Component configuration.
         */
        configure(configuration) {
            this._configurationSubject$.next(configuration);
        }
        /** @ignore */
        deactivate() {
            if (!this._activated) {
                return;
            }
            this._activated = false;
            this._deactivate();
            this._container.domRenderer.clear(this._name);
            this._container.glRenderer.clear(this._name);
            this._activated$.next(false);
        }
        /** @inheritdoc */
        fire(type, event) {
            super.fire(type, event);
        }
        /** @inheritdoc */
        off(type, handler) {
            super.off(type, handler);
        }
        /** @inheritdoc */
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Detect the viewer's new width and height and resize the component's
         * rendered elements accordingly if applicable.
         *
         * @ignore
         */
        resize() { return; }
    }

    var CoverState;
    (function (CoverState) {
        CoverState[CoverState["Hidden"] = 0] = "Hidden";
        CoverState[CoverState["Loading"] = 1] = "Loading";
        CoverState[CoverState["Visible"] = 2] = "Visible";
    })(CoverState || (CoverState = {}));

    class CoverComponent extends Component {
        constructor(name, container, navigator) {
            super(name, container, navigator);
        }
        _activate() {
            const originalSrc$ = this.configuration$.pipe(first((c) => {
                return !!c.id;
            }), filter((c) => {
                return !c.src;
            }), switchMap((c) => {
                return this._getImageSrc$(c.id).pipe(catchError((error) => {
                    console.error(error);
                    return empty();
                }));
            }), publishReplay(1), refCount());
            const subs = this._subscriptions;
            subs.push(originalSrc$.pipe(map((src) => {
                return { src: src };
            }))
                .subscribe((c) => {
                this._configurationSubject$.next(c);
            }));
            subs.push(combineLatest(this.configuration$, originalSrc$).pipe(filter(([c, src]) => {
                return !!c.src && c.src !== src;
            }), first())
                .subscribe(([, src]) => {
                window.URL.revokeObjectURL(src);
            }));
            subs.push(this._configuration$.pipe(distinctUntilChanged(undefined, (configuration) => {
                return configuration.state;
            }), switchMap((configuration) => {
                return combineLatest(of(configuration.state), this._navigator.stateService.currentImage$);
            }), switchMap(([state, image]) => {
                const keySrc$ = combineLatest(of(image.id), image.image$.pipe(filter((imageElement) => {
                    return !!imageElement;
                }), map((imageElement) => {
                    return imageElement.src;
                })));
                return state === CoverState.Visible ? keySrc$.pipe(first()) : keySrc$;
            }), distinctUntilChanged(([k1, s1], [k2, s2]) => {
                return k1 === k2 && s1 === s2;
            }), map(([key, src]) => {
                return { id: key, src: src };
            }))
                .subscribe(this._configurationSubject$));
            subs.push(combineLatest(this._configuration$, this._container.configurationService.exploreUrl$, this._container.renderService.size$).pipe(map(([configuration, exploreUrl, size]) => {
                if (!configuration.src) {
                    return { name: this._name, vNode: virtualDom.h("div", []) };
                }
                const compactClass = size.width <= 640 || size.height <= 480 ? ".mapillary-cover-compact" : "";
                if (configuration.state === CoverState.Hidden) {
                    const doneContainer = virtualDom.h("div.mapillary-cover-container.mapillary-cover-done" + compactClass, [this._getCoverBackgroundVNode(configuration)]);
                    return { name: this._name, vNode: doneContainer };
                }
                const container = virtualDom.h("div.mapillary-cover-container" + compactClass, [this._getCoverButtonVNode(configuration, exploreUrl)]);
                return { name: this._name, vNode: container };
            }))
                .subscribe(this._container.domRenderer.render$));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return { state: CoverState.Visible };
        }
        _getCoverButtonVNode(configuration, exploreUrl) {
            const cover = configuration.state === CoverState.Loading ? "div.mapillary-cover.mapillary-cover-loading" : "div.mapillary-cover";
            const coverButton = virtualDom.h("div.mapillary-cover-button", [virtualDom.h("div.mapillary-cover-button-icon", [])]);
            const coverLogo = virtualDom.h("a.mapillary-cover-logo", { href: exploreUrl, target: "_blank" }, []);
            const coverIndicator = virtualDom.h("div.mapillary-cover-indicator", { onclick: () => { this.configure({ state: CoverState.Loading }); } }, []);
            return virtualDom.h(cover, [
                this._getCoverBackgroundVNode(configuration),
                coverIndicator,
                coverButton,
                coverLogo,
            ]);
        }
        _getCoverBackgroundVNode(conf) {
            const properties = {
                style: { backgroundImage: `url(${conf.src})` },
            };
            const children = [];
            if (conf.state === CoverState.Loading) {
                children.push(virtualDom.h("div.mapillary-cover-spinner", {}, []));
            }
            return virtualDom.h("div.mapillary-cover-background", properties, children);
        }
        _getImageSrc$(id) {
            return Observable.create((subscriber) => {
                this._navigator.api.getImages$([id])
                    .subscribe((items) => {
                    for (const item of items) {
                        if (item.node_id !== id) {
                            continue;
                        }
                        this._navigator.api.data
                            .getImageBuffer(item.node.thumb.url)
                            .then((buffer) => {
                            const image = new Image();
                            image.crossOrigin = "Anonymous";
                            image.onload = () => {
                                subscriber.next(image.src);
                                subscriber.complete();
                            };
                            image.onerror = () => {
                                subscriber.error(new Error(`Failed to load cover ` +
                                    `image (${id})`));
                            };
                            const blob = new Blob([buffer]);
                            image.src = window.URL
                                .createObjectURL(blob);
                        }, (error) => {
                            subscriber.error(error);
                        });
                        return;
                    }
                    subscriber.error(new MapillaryError(`Non existent cover key: ${id}`));
                }, (error) => {
                    subscriber.error(error);
                });
            });
        }
    }
    CoverComponent.componentName = "cover";

    class AttributionComponent extends Component {
        _activate() {
            this._subscriptions.push(combineLatest(this._container.configurationService.exploreUrl$, this._navigator.stateService.currentImage$, this._container.renderService.size$).pipe(map(([exploreUrl, image, size]) => {
                const attribution = this._makeAttribution(image.creatorUsername, exploreUrl, image.id, image.capturedAt, size.width);
                return {
                    name: this._name,
                    vNode: attribution,
                };
            }))
                .subscribe(this._container.domRenderer.render$));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return {};
        }
        makeImageUrl(exploreUrl, id) {
            return `${exploreUrl}/app/?pKey=${id}&focus=photo`;
        }
        _makeAttribution(creatorUsername, exploreUrl, imageId, capturedAt, viewportWidth) {
            const compact = viewportWidth <= 640;
            const date = this._makeDate(capturedAt, compact);
            const by = this._makeBy(creatorUsername, exploreUrl, imageId, compact);
            const compactClass = compact ?
                ".mapillary-attribution-compact" : "";
            return virtualDom.h("div.mapillary-attribution-container" + compactClass, {}, [...by, date]);
        }
        _makeBy(creatorUsername, exploreUrl, imageId, compact) {
            const icon = virtualDom.h("div.mapillary-attribution-logo", []);
            return creatorUsername ?
                this._makeCreatorBy(icon, creatorUsername, exploreUrl, imageId, compact) :
                this._makeGeneralBy(icon, exploreUrl, imageId, compact);
        }
        _makeCreatorBy(icon, creatorUsername, exploreUrl, imageId, compact) {
            const mapillary = virtualDom.h("a.mapillary-attribution-icon-container", { href: exploreUrl, rel: "noreferrer", target: "_blank" }, [icon]);
            const content = compact ?
                `${creatorUsername}` : `image by ${creatorUsername}`;
            const imageBy = virtualDom.h("div.mapillary-attribution-username", { textContent: content }, []);
            const image = virtualDom.h("a.mapillary-attribution-image-container", {
                href: this.makeImageUrl(exploreUrl, imageId),
                rel: "noreferrer",
                target: "_blank",
            }, [imageBy]);
            return [mapillary, image];
        }
        _makeGeneralBy(icon, exploreUrl, imageId, compact) {
            const imagesBy = virtualDom.h("div.mapillary-attribution-username", { textContent: 'images by' }, []);
            const mapillary = virtualDom.h("div.mapillary-attribution-icon-container", {}, [icon]);
            const contributors = virtualDom.h("div.mapillary-attribution-username", { textContent: 'contributors' }, []);
            const children = [mapillary, contributors];
            if (!compact) {
                children.unshift(imagesBy);
            }
            const image = virtualDom.h("a.mapillary-attribution-image-container", {
                href: this.makeImageUrl(exploreUrl, imageId),
                rel: "noreferrer",
                target: "_blank",
            }, children);
            return [image];
        }
        _makeDate(capturedAt, compact) {
            const date = new Date(capturedAt)
                .toDateString()
                .split(" ");
            const formatted = (date.length > 3 ?
                compact ?
                    [date[3]] :
                    [date[1], date[2] + ",", date[3]] :
                date).join(" ");
            return virtualDom.h("div.mapillary-attribution-date", { textContent: formatted }, []);
        }
    }
    AttributionComponent.componentName = "attribution";

    /**
     * @class ViewportCoords
     *
     * @classdesc Provides methods for calculating 2D coordinate conversions
     * as well as 3D projection and unprojection.
     *
     * Basic coordinates are 2D coordinates on the [0, 1] interval and
     * have the origin point, (0, 0), at the top left corner and the
     * maximum value, (1, 1), at the bottom right corner of the original
     * image.
     *
     * Viewport coordinates are 2D coordinates on the [-1, 1] interval and
     * have the origin point in the center. The bottom left corner point is
     * (-1, -1) and the top right corner point is (1, 1).
     *
     * Canvas coordiantes are 2D pixel coordinates on the [0, canvasWidth] and
     * [0, canvasHeight] intervals. The origin point (0, 0) is in the top left
     * corner and the maximum value is (canvasWidth, canvasHeight) is in the
     * bottom right corner.
     *
     * 3D coordinates are in the topocentric world reference frame.
     */
    class ViewportCoords {
        constructor() {
            this._unprojectDepth = 200;
        }
        /**
         * Convert basic coordinates to canvas coordinates.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * @param {number} basicX - Basic X coordinate.
         * @param {number} basicY - Basic Y coordinate.
         * @param {HTMLElement} container - The viewer container.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D canvas coordinates.
         */
        basicToCanvas(basicX, basicY, container, transform, camera) {
            const point3d = transform.unprojectBasic([basicX, basicY], this._unprojectDepth);
            const canvas = this.projectToCanvas(point3d, container, camera);
            return canvas;
        }
        /**
         * Convert basic coordinates to canvas coordinates safely. If 3D point is
         * behind camera null will be returned.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * @param {number} basicX - Basic X coordinate.
         * @param {number} basicY - Basic Y coordinate.
         * @param {HTMLElement} container - The viewer container.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D canvas coordinates if the basic point represents a 3D point
         * in front of the camera, otherwise null.
         */
        basicToCanvasSafe(basicX, basicY, container, transform, camera) {
            const viewport = this.basicToViewportSafe(basicX, basicY, transform, camera);
            if (viewport === null) {
                return null;
            }
            const canvas = this.viewportToCanvas(viewport[0], viewport[1], container);
            return canvas;
        }
        /**
         * Convert basic coordinates to viewport coordinates.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * @param {number} basicX - Basic X coordinate.
         * @param {number} basicY - Basic Y coordinate.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D viewport coordinates.
         */
        basicToViewport(basicX, basicY, transform, camera) {
            const point3d = transform.unprojectBasic([basicX, basicY], this._unprojectDepth);
            const viewport = this.projectToViewport(point3d, camera);
            return viewport;
        }
        /**
         * Convert basic coordinates to viewport coordinates safely. If 3D point is
         * behind camera null will be returned.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * @param {number} basicX - Basic X coordinate.
         * @param {number} basicY - Basic Y coordinate.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D viewport coordinates.
         */
        basicToViewportSafe(basicX, basicY, transform, camera) {
            const point3d = transform.unprojectBasic([basicX, basicY], this._unprojectDepth);
            const pointCamera = this.worldToCamera(point3d, camera);
            if (pointCamera[2] > 0) {
                return null;
            }
            const viewport = this.projectToViewport(point3d, camera);
            return viewport;
        }
        /**
         * Convert camera 3D coordinates to viewport coordinates.
         *
         * @param {number} pointCamera - 3D point in camera coordinate system.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D viewport coordinates.
         */
        cameraToViewport(pointCamera, camera) {
            const viewport = new Vector3().fromArray(pointCamera)
                .applyMatrix4(camera.projectionMatrix);
            return [viewport.x, viewport.y];
        }
        /**
         * Get canvas pixel position from event.
         *
         * @param {Event} event - Event containing clientX and clientY properties.
         * @param {HTMLElement} element - HTML element.
         * @returns {Array<number>} 2D canvas coordinates.
         */
        canvasPosition(event, element) {
            const clientRect = element.getBoundingClientRect();
            const canvasX = event.clientX - clientRect.left - element.clientLeft;
            const canvasY = event.clientY - clientRect.top - element.clientTop;
            return [canvasX, canvasY];
        }
        /**
         * Convert canvas coordinates to basic coordinates.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * @param {number} canvasX - Canvas X coordinate.
         * @param {number} canvasY - Canvas Y coordinate.
         * @param {HTMLElement} container - The viewer container.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D basic coordinates.
         */
        canvasToBasic(canvasX, canvasY, container, transform, camera) {
            const point3d = this.unprojectFromCanvas(canvasX, canvasY, container, camera)
                .toArray();
            const basic = transform.projectBasic(point3d);
            return basic;
        }
        /**
         * Convert canvas coordinates to viewport coordinates.
         *
         * @param {number} canvasX - Canvas X coordinate.
         * @param {number} canvasY - Canvas Y coordinate.
         * @param {HTMLElement} container - The viewer container.
         * @returns {Array<number>} 2D viewport coordinates.
         */
        canvasToViewport(canvasX, canvasY, container) {
            const [canvasWidth, canvasHeight] = this.containerToCanvas(container);
            const viewportX = 2 * canvasX / canvasWidth - 1;
            const viewportY = 1 - 2 * canvasY / canvasHeight;
            return [viewportX, viewportY];
        }
        /**
         * Determines the width and height of the container in canvas coordinates.
         *
         * @param {HTMLElement} container - The viewer container.
         * @returns {Array<number>} 2D canvas coordinates.
         */
        containerToCanvas(container) {
            return [container.offsetWidth, container.offsetHeight];
        }
        /**
         * Determine basic distances from image to canvas corners.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * Determines the smallest basic distance for every side of the canvas.
         *
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} Array of basic distances as [top, right, bottom, left].
         */
        getBasicDistances(transform, camera) {
            const topLeftBasic = this.viewportToBasic(-1, 1, transform, camera);
            const topRightBasic = this.viewportToBasic(1, 1, transform, camera);
            const bottomRightBasic = this.viewportToBasic(1, -1, transform, camera);
            const bottomLeftBasic = this.viewportToBasic(-1, -1, transform, camera);
            let topBasicDistance = 0;
            let rightBasicDistance = 0;
            let bottomBasicDistance = 0;
            let leftBasicDistance = 0;
            if (topLeftBasic[1] < 0 && topRightBasic[1] < 0) {
                topBasicDistance = topLeftBasic[1] > topRightBasic[1] ?
                    -topLeftBasic[1] :
                    -topRightBasic[1];
            }
            if (topRightBasic[0] > 1 && bottomRightBasic[0] > 1) {
                rightBasicDistance = topRightBasic[0] < bottomRightBasic[0] ?
                    topRightBasic[0] - 1 :
                    bottomRightBasic[0] - 1;
            }
            if (bottomRightBasic[1] > 1 && bottomLeftBasic[1] > 1) {
                bottomBasicDistance = bottomRightBasic[1] < bottomLeftBasic[1] ?
                    bottomRightBasic[1] - 1 :
                    bottomLeftBasic[1] - 1;
            }
            if (bottomLeftBasic[0] < 0 && topLeftBasic[0] < 0) {
                leftBasicDistance = bottomLeftBasic[0] > topLeftBasic[0] ?
                    -bottomLeftBasic[0] :
                    -topLeftBasic[0];
            }
            return [topBasicDistance, rightBasicDistance, bottomBasicDistance, leftBasicDistance];
        }
        /**
         * Determine pixel distances from image to canvas corners.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * Determines the smallest pixel distance for every side of the canvas.
         *
         * @param {HTMLElement} container - The viewer container.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} Array of pixel distances as [top, right, bottom, left].
         */
        getPixelDistances(container, transform, camera) {
            const topLeftBasic = this.viewportToBasic(-1, 1, transform, camera);
            const topRightBasic = this.viewportToBasic(1, 1, transform, camera);
            const bottomRightBasic = this.viewportToBasic(1, -1, transform, camera);
            const bottomLeftBasic = this.viewportToBasic(-1, -1, transform, camera);
            let topPixelDistance = 0;
            let rightPixelDistance = 0;
            let bottomPixelDistance = 0;
            let leftPixelDistance = 0;
            const [canvasWidth, canvasHeight] = this.containerToCanvas(container);
            if (topLeftBasic[1] < 0 && topRightBasic[1] < 0) {
                const basicX = topLeftBasic[1] > topRightBasic[1] ?
                    topLeftBasic[0] :
                    topRightBasic[0];
                const canvas = this.basicToCanvas(basicX, 0, container, transform, camera);
                topPixelDistance = canvas[1] > 0 ? canvas[1] : 0;
            }
            if (topRightBasic[0] > 1 && bottomRightBasic[0] > 1) {
                const basicY = topRightBasic[0] < bottomRightBasic[0] ?
                    topRightBasic[1] :
                    bottomRightBasic[1];
                const canvas = this.basicToCanvas(1, basicY, container, transform, camera);
                rightPixelDistance = canvas[0] < canvasWidth ? canvasWidth - canvas[0] : 0;
            }
            if (bottomRightBasic[1] > 1 && bottomLeftBasic[1] > 1) {
                const basicX = bottomRightBasic[1] < bottomLeftBasic[1] ?
                    bottomRightBasic[0] :
                    bottomLeftBasic[0];
                const canvas = this.basicToCanvas(basicX, 1, container, transform, camera);
                bottomPixelDistance = canvas[1] < canvasHeight ? canvasHeight - canvas[1] : 0;
            }
            if (bottomLeftBasic[0] < 0 && topLeftBasic[0] < 0) {
                const basicY = bottomLeftBasic[0] > topLeftBasic[0] ?
                    bottomLeftBasic[1] :
                    topLeftBasic[1];
                const canvas = this.basicToCanvas(0, basicY, container, transform, camera);
                leftPixelDistance = canvas[0] > 0 ? canvas[0] : 0;
            }
            return [topPixelDistance, rightPixelDistance, bottomPixelDistance, leftPixelDistance];
        }
        /**
         * Determine if an event occured inside an element.
         *
         * @param {Event} event - Event containing clientX and clientY properties.
         * @param {HTMLElement} element - HTML element.
         * @returns {boolean} Value indicating if the event occured inside the element or not.
         */
        insideElement(event, element) {
            const clientRect = element.getBoundingClientRect();
            const minX = clientRect.left + element.clientLeft;
            const maxX = minX + element.clientWidth;
            const minY = clientRect.top + element.clientTop;
            const maxY = minY + element.clientHeight;
            return event.clientX > minX &&
                event.clientX < maxX &&
                event.clientY > minY &&
                event.clientY < maxY;
        }
        /**
         * Project 3D world coordinates to canvas coordinates.
         *
         * @param {Array<number>} point3D - 3D world coordinates.
         * @param {HTMLElement} container - The viewer container.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D canvas coordinates.
         */
        projectToCanvas(point3d, container, camera) {
            const viewport = this.projectToViewport(point3d, camera);
            const canvas = this.viewportToCanvas(viewport[0], viewport[1], container);
            return canvas;
        }
        /**
         * Project 3D world coordinates to canvas coordinates safely. If 3D
         * point is behind camera null will be returned.
         *
         * @param {Array<number>} point3D - 3D world coordinates.
         * @param {HTMLElement} container - The viewer container.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D canvas coordinates.
         */
        projectToCanvasSafe(point3d, container, camera) {
            const pointCamera = this.worldToCamera(point3d, camera);
            if (pointCamera[2] > 0) {
                return null;
            }
            const viewport = this.projectToViewport(point3d, camera);
            const canvas = this.viewportToCanvas(viewport[0], viewport[1], container);
            return canvas;
        }
        /**
         * Project 3D world coordinates to viewport coordinates.
         *
         * @param {Array<number>} point3D - 3D world coordinates.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D viewport coordinates.
         */
        projectToViewport(point3d, camera) {
            const viewport = new Vector3(point3d[0], point3d[1], point3d[2])
                .project(camera);
            return [viewport.x, viewport.y];
        }
        /**
         * Uproject canvas coordinates to 3D world coordinates.
         *
         * @param {number} canvasX - Canvas X coordinate.
         * @param {number} canvasY - Canvas Y coordinate.
         * @param {HTMLElement} container - The viewer container.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 3D world coordinates.
         */
        unprojectFromCanvas(canvasX, canvasY, container, camera) {
            const viewport = this.canvasToViewport(canvasX, canvasY, container);
            const point3d = this.unprojectFromViewport(viewport[0], viewport[1], camera);
            return point3d;
        }
        /**
         * Unproject viewport coordinates to 3D world coordinates.
         *
         * @param {number} viewportX - Viewport X coordinate.
         * @param {number} viewportY - Viewport Y coordinate.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 3D world coordinates.
         */
        unprojectFromViewport(viewportX, viewportY, camera) {
            const point3d = new Vector3(viewportX, viewportY, 1)
                .unproject(camera);
            return point3d;
        }
        /**
         * Convert viewport coordinates to basic coordinates.
         *
         * @description Transform origin and camera position needs to be the
         * equal for reliable return value.
         *
         * @param {number} viewportX - Viewport X coordinate.
         * @param {number} viewportY - Viewport Y coordinate.
         * @param {Transform} transform - Transform of the image to unproject from.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 2D basic coordinates.
         */
        viewportToBasic(viewportX, viewportY, transform, camera) {
            const point3d = new Vector3(viewportX, viewportY, 1)
                .unproject(camera)
                .toArray();
            const basic = transform.projectBasic(point3d);
            return basic;
        }
        /**
         * Convert viewport coordinates to canvas coordinates.
         *
         * @param {number} viewportX - Viewport X coordinate.
         * @param {number} viewportY - Viewport Y coordinate.
         * @param {HTMLElement} container - The viewer container.
         * @returns {Array<number>} 2D canvas coordinates.
         */
        viewportToCanvas(viewportX, viewportY, container) {
            const [canvasWidth, canvasHeight] = this.containerToCanvas(container);
            const canvasX = canvasWidth * (viewportX + 1) / 2;
            const canvasY = -canvasHeight * (viewportY - 1) / 2;
            return [canvasX, canvasY];
        }
        /**
         * Convert 3D world coordinates to 3D camera coordinates.
         *
         * @param {number} point3D - 3D point in world coordinate system.
         * @param {THREE.Camera} camera - Camera used in rendering.
         * @returns {Array<number>} 3D camera coordinates.
         */
        worldToCamera(point3d, camera) {
            const pointCamera = new Vector3(point3d[0], point3d[1], point3d[2])
                .applyMatrix4(camera.matrixWorldInverse);
            return pointCamera.toArray();
        }
    }

    /**
     * Enumeration for component size.
     * @enum {number}
     * @readonly
     * @description May be used by a component to allow for resizing
     * of the UI elements rendered by the component.
     */
    exports.ComponentSize = void 0;
    (function (ComponentSize) {
        /**
         * Automatic size. The size of the elements will automatically
         * change at a predefined threshold.
         */
        ComponentSize[ComponentSize["Automatic"] = 0] = "Automatic";
        /**
         * Large size. The size of the elements will be fixed until another
         * component size is configured.
         */
        ComponentSize[ComponentSize["Large"] = 1] = "Large";
        /**
         * Small size. The size of the elements will be fixed until another
         * component size is configured.
         */
        ComponentSize[ComponentSize["Small"] = 2] = "Small";
    })(exports.ComponentSize || (exports.ComponentSize = {}));

    /**
     * @class BearingComponent
     *
     * @classdesc Component for indicating bearing and field of view.
     *
     * @example
     * ```js
     * var viewer = new Viewer({ ... });
     * var bearingComponent = viewer.getComponent("bearing");
     * bearingComponent.configure({ size: ComponentSize.Small });
     * ```
     */
    class BearingComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._spatial = new Spatial();
            this._viewportCoords = new ViewportCoords();
            this._svgNamespace = "http://www.w3.org/2000/svg";
            this._distinctThreshold = Math.PI / 360;
            this._animationSpeed = 0.075;
            this._unitBezier = new unitbezier(0.74, 0.67, 0.38, 0.96);
        }
        _activate() {
            const subs = this._subscriptions;
            const cameraBearingFov$ = this._container.renderService.renderCamera$.pipe(map((rc) => {
                let vFov = this._spatial.degToRad(rc.perspective.fov);
                let hFov = rc.perspective.aspect === Number.POSITIVE_INFINITY ?
                    Math.PI :
                    Math.atan(rc.perspective.aspect * Math.tan(0.5 * vFov)) * 2;
                return [this._spatial.azimuthalToBearing(rc.rotation.phi), hFov];
            }), distinctUntilChanged((a1, a2) => {
                return Math.abs(a2[0] - a1[0]) < this._distinctThreshold &&
                    Math.abs(a2[1] - a1[1]) < this._distinctThreshold;
            }));
            const imageFov$ = combineLatest(this._navigator.stateService.currentState$.pipe(distinctUntilChanged(undefined, (frame) => {
                return frame.state.currentImage.id;
            })), this._navigator.panService.panImages$).pipe(map(([frame, panImages]) => {
                const image = frame.state.currentImage;
                const transform = frame.state.currentTransform;
                if (isSpherical(image.cameraType)) {
                    return [Math.PI, Math.PI];
                }
                const currentProjectedPoints = this._computeProjectedPoints(transform);
                const hFov = this._spatial
                    .degToRad(this._computeHorizontalFov(currentProjectedPoints));
                let hFovLeft = hFov / 2;
                let hFovRight = hFov / 2;
                for (const [n, , f] of panImages) {
                    const diff = this._spatial.wrap(n.compassAngle - image.compassAngle, -180, 180);
                    if (diff < 0) {
                        hFovLeft = this._spatial.degToRad(Math.abs(diff)) + f / 2;
                    }
                    else {
                        hFovRight = this._spatial.degToRad(Math.abs(diff)) + f / 2;
                    }
                }
                return [hFovLeft, hFovRight];
            }), distinctUntilChanged(([hFovLeft1, hFovRight1], [hFovLeft2, hFovRight2]) => {
                return Math.abs(hFovLeft2 - hFovLeft1) < this._distinctThreshold &&
                    Math.abs(hFovRight2 - hFovRight1) < this._distinctThreshold;
            }));
            const offset$ = combineLatest(this._navigator.stateService.currentState$.pipe(distinctUntilChanged(undefined, (frame) => {
                return frame.state.currentImage.id;
            })), this._container.renderService.bearing$).pipe(map(([frame, bearing]) => {
                const offset = this._spatial.degToRad(frame.state.currentImage.compassAngle - bearing);
                return offset;
            }));
            const imageFovOperation$ = new Subject();
            const smoothImageFov$ = imageFovOperation$.pipe(scan((state, operation) => {
                return operation(state);
            }, { alpha: 0, curr: [0, 0, 0], prev: [0, 0, 0] }), map((state) => {
                const alpha = this._unitBezier.solve(state.alpha);
                const curr = state.curr;
                const prev = state.prev;
                return [
                    this._interpolate(prev[0], curr[0], alpha),
                    this._interpolate(prev[1], curr[1], alpha),
                ];
            }));
            subs.push(imageFov$.pipe(map((nbf) => {
                return (state) => {
                    const a = this._unitBezier.solve(state.alpha);
                    const c = state.curr;
                    const p = state.prev;
                    const prev = [
                        this._interpolate(p[0], c[0], a),
                        this._interpolate(p[1], c[1], a),
                    ];
                    const curr = nbf.slice();
                    return {
                        alpha: 0,
                        curr: curr,
                        prev: prev,
                    };
                };
            }))
                .subscribe(imageFovOperation$));
            subs.push(imageFov$.pipe(switchMap(() => {
                return this._container.renderService.renderCameraFrame$.pipe(skip(1), scan((alpha) => {
                    return alpha + this._animationSpeed;
                }, 0), takeWhile((alpha) => {
                    return alpha <= 1 + this._animationSpeed;
                }), map((alpha) => {
                    return Math.min(alpha, 1);
                }));
            }), map((alpha) => {
                return (nbfState) => {
                    return {
                        alpha: alpha,
                        curr: nbfState.curr.slice(),
                        prev: nbfState.prev.slice(),
                    };
                };
            }))
                .subscribe(imageFovOperation$));
            const imageBearingFov$ = combineLatest(offset$, smoothImageFov$).pipe(map(([offset, fov]) => {
                return [offset, fov[0], fov[1]];
            }));
            subs.push(combineLatest(cameraBearingFov$, imageBearingFov$, this._configuration$, this._container.renderService.size$).pipe(map(([[cb, cf], [no, nfl, nfr], configuration, size]) => {
                const background = this._createBackground(cb);
                const fovIndicator = this._createFovIndicator(nfl, nfr, no);
                const north = this._createNorth(cb);
                const cameraSector = this._createCircleSectorCompass(this._createCircleSector(Math.max(Math.PI / 20, cf), "#FFF"));
                const compact = configuration.size === exports.ComponentSize.Small ||
                    configuration.size === exports.ComponentSize.Automatic && size.width < 640 ?
                    ".mapillary-bearing-compact" : "";
                return {
                    name: this._name,
                    vNode: virtualDom.h("div.mapillary-bearing-indicator-container" + compact, { oncontextmenu: (event) => { event.preventDefault(); } }, [
                        background,
                        fovIndicator,
                        north,
                        cameraSector,
                    ]),
                };
            }))
                .subscribe(this._container.domRenderer.render$));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return { size: exports.ComponentSize.Automatic };
        }
        _createFovIndicator(fovLeft, fovRigth, offset) {
            const arc = this._createFovArc(fovLeft, fovRigth);
            const group = virtualDom.h("g", {
                attributes: { transform: "translate(18,18)" },
                namespace: this._svgNamespace,
            }, [arc]);
            const svg = virtualDom.h("svg", {
                attributes: { viewBox: "0 0 36 36" },
                namespace: this._svgNamespace,
                style: {
                    height: "36px",
                    left: "2px",
                    position: "absolute",
                    top: "2px",
                    transform: `rotateZ(${this._spatial.radToDeg(offset)}deg)`,
                    width: "36px",
                },
            }, [group]);
            return svg;
        }
        _createFovArc(fovLeft, fovRigth) {
            const radius = 16.75;
            const strokeWidth = 2.5;
            const fov = fovLeft + fovRigth;
            if (fov > 2 * Math.PI - Math.PI / 90) {
                return virtualDom.h("circle", {
                    attributes: {
                        cx: "0",
                        cy: "0",
                        "fill-opacity": "0",
                        r: `${radius}`,
                        stroke: "#FFF",
                        "stroke-width": `${strokeWidth}`,
                    },
                    namespace: this._svgNamespace,
                }, []);
            }
            let arcStart = -Math.PI / 2 - fovLeft;
            let arcEnd = arcStart + fov;
            let startX = radius * Math.cos(arcStart);
            let startY = radius * Math.sin(arcStart);
            let endX = radius * Math.cos(arcEnd);
            let endY = radius * Math.sin(arcEnd);
            let largeArc = fov >= Math.PI ? 1 : 0;
            let description = `M ${startX} ${startY} A ${radius} ${radius} 0 ${largeArc} 1 ${endX} ${endY}`;
            return virtualDom.h("path", {
                attributes: {
                    d: description,
                    "fill-opacity": "0",
                    stroke: "#FFF",
                    "stroke-width": `${strokeWidth}`,
                },
                namespace: this._svgNamespace,
            }, []);
        }
        _createCircleSectorCompass(cameraSector) {
            let group = virtualDom.h("g", {
                attributes: { transform: "translate(1,1)" },
                namespace: this._svgNamespace,
            }, [cameraSector]);
            let svg = virtualDom.h("svg", {
                attributes: { viewBox: "0 0 2 2" },
                namespace: this._svgNamespace,
                style: {
                    height: "26px",
                    left: "7px",
                    position: "absolute",
                    top: "7px",
                    width: "26px",
                },
            }, [group]);
            return svg;
        }
        _createCircleSector(fov, fill) {
            if (fov > 2 * Math.PI - Math.PI / 90) {
                return virtualDom.h("circle", {
                    attributes: { cx: "0", cy: "0", fill: fill, r: "1" },
                    namespace: this._svgNamespace,
                }, []);
            }
            let arcStart = -Math.PI / 2 - fov / 2;
            let arcEnd = arcStart + fov;
            let startX = Math.cos(arcStart);
            let startY = Math.sin(arcStart);
            let endX = Math.cos(arcEnd);
            let endY = Math.sin(arcEnd);
            let largeArc = fov >= Math.PI ? 1 : 0;
            let description = `M 0 0 ${startX} ${startY} A 1 1 0 ${largeArc} 1 ${endX} ${endY}`;
            return virtualDom.h("path", {
                attributes: { d: description, fill: fill },
                namespace: this._svgNamespace,
            }, []);
        }
        _createNorth(bearing) {
            const north = virtualDom.h("div.mapillary-bearing-north", []);
            const container = virtualDom.h("div.mapillary-bearing-north-container", { style: { transform: `rotateZ(${this._spatial.radToDeg(-bearing)}deg)` } }, [north]);
            return container;
        }
        _createBackground(bearing) {
            return virtualDom.h("div.mapillary-bearing-indicator-background", { style: { transform: `rotateZ(${this._spatial.radToDeg(-bearing)}deg)` } }, [
                virtualDom.h("div.mapillary-bearing-indicator-background-circle", []),
                virtualDom.h("div.mapillary-bearing-indicator-background-arrow-container", [
                    virtualDom.h("div.mapillary-bearing-indicator-background-arrow", []),
                ]),
            ]);
        }
        _computeProjectedPoints(transform) {
            const vertices = [[1, 0]];
            const directions = [[0, 0.5]];
            const pointsPerLine = 12;
            return computeProjectedPoints(transform, vertices, directions, pointsPerLine, this._viewportCoords);
        }
        _computeHorizontalFov(projectedPoints) {
            const fovs = projectedPoints
                .map((projectedPoint) => {
                return this._coordToFov(projectedPoint[0]);
            });
            const fov = Math.min(...fovs);
            return fov;
        }
        _coordToFov(x) {
            return this._spatial.radToDeg(2 * Math.atan(x));
        }
        _interpolate(x1, x2, alpha) {
            return (1 - alpha) * x1 + alpha * x2;
        }
    }
    BearingComponent.componentName = "bearing";

    class CacheComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
        }
        _activate() {
            const subs = this._subscriptions;
            subs.push(combineLatest(this._navigator.stateService.currentImage$.pipe(switchMap((image) => {
                return image.sequenceEdges$;
            }), filter((status) => {
                return status.cached;
            })), this._configuration$).pipe(switchMap((nc) => {
                let status = nc[0];
                let configuration = nc[1];
                let sequenceDepth = Math.max(0, Math.min(4, configuration.depth.sequence));
                let next$ = this._cache$(status.edges, exports.NavigationDirection.Next, sequenceDepth);
                let prev$ = this._cache$(status.edges, exports.NavigationDirection.Prev, sequenceDepth);
                return merge(next$, prev$).pipe(catchError((error) => {
                    console.error("Failed to cache sequence edges.", error);
                    return empty();
                }));
            }))
                .subscribe(() => { }));
            subs.push(combineLatest(this._navigator.stateService.currentImage$.pipe(switchMap((image) => {
                return combineLatest(of(image), image.spatialEdges$.pipe(filter((status) => {
                    return status.cached;
                })));
            })), this._configuration$).pipe(switchMap(([[image, edgeStatus], configuration]) => {
                let edges = edgeStatus.edges;
                let depth = configuration.depth;
                let sphericalDepth = Math.max(0, Math.min(2, depth.spherical));
                let stepDepth = isSpherical(image.cameraType) ?
                    0 : Math.max(0, Math.min(3, depth.step));
                let turnDepth = isSpherical(image.cameraType) ?
                    0 : Math.max(0, Math.min(1, depth.turn));
                let spherical$ = this._cache$(edges, exports.NavigationDirection.Spherical, sphericalDepth);
                let forward$ = this._cache$(edges, exports.NavigationDirection.StepForward, stepDepth);
                let backward$ = this._cache$(edges, exports.NavigationDirection.StepBackward, stepDepth);
                let left$ = this._cache$(edges, exports.NavigationDirection.StepLeft, stepDepth);
                let right$ = this._cache$(edges, exports.NavigationDirection.StepRight, stepDepth);
                let turnLeft$ = this._cache$(edges, exports.NavigationDirection.TurnLeft, turnDepth);
                let turnRight$ = this._cache$(edges, exports.NavigationDirection.TurnRight, turnDepth);
                let turnU$ = this._cache$(edges, exports.NavigationDirection.TurnU, turnDepth);
                return merge(forward$, backward$, left$, right$, spherical$, turnLeft$, turnRight$, turnU$).pipe(catchError((error) => {
                    console.error("Failed to cache spatial edges.", error);
                    return empty();
                }));
            }))
                .subscribe(() => { }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return { depth: { spherical: 1, sequence: 2, step: 1, turn: 0 } };
        }
        _cache$(edges, direction, depth) {
            return zip(of(edges), of(depth)).pipe(expand((ed) => {
                let es = ed[0];
                let d = ed[1];
                let edgesDepths$ = [];
                if (d > 0) {
                    for (let edge of es) {
                        if (edge.data.direction === direction) {
                            edgesDepths$.push(zip(this._navigator.graphService.cacheImage$(edge.target).pipe(mergeMap((n) => {
                                return this._imageToEdges$(n, direction);
                            })), of(d - 1)));
                        }
                    }
                }
                return from(edgesDepths$).pipe(mergeAll());
            }), skip(1));
        }
        _imageToEdges$(image, direction) {
            return ([exports.NavigationDirection.Next, exports.NavigationDirection.Prev].indexOf(direction) > -1 ?
                image.sequenceEdges$ :
                image.spatialEdges$).pipe(first((status) => {
                return status.cached;
            }), map((status) => {
                return status.edges;
            }));
        }
    }
    CacheComponent.componentName = "cache";

    /**
     * @class CancelMapillaryError
     *
     * @classdesc Error thrown when a move to request has been
     * cancelled before completing because of a subsequent request.
     */
    class CancelMapillaryError extends MapillaryError {
        constructor(message) {
            super(message != null ? message : "The request was cancelled.");
            Object.setPrototypeOf(this, CancelMapillaryError.prototype);
            this.name = "CancelMapillaryError";
        }
    }

    /**
     * @class DirectionDOMCalculator
     * @classdesc Helper class for calculating DOM CSS properties.
     */
    class DirectionDOMCalculator {
        constructor(configuration, size) {
            this._spatial = new Spatial();
            this._minThresholdWidth = 320;
            this._maxThresholdWidth = 1480;
            this._minThresholdHeight = 240;
            this._maxThresholdHeight = 820;
            this._configure(configuration);
            this._resize(size);
            this._reset();
        }
        get minWidth() {
            return this._minWidth;
        }
        get maxWidth() {
            return this._maxWidth;
        }
        get containerWidth() {
            return this._containerWidth;
        }
        get containerWidthCss() {
            return this._containerWidthCss;
        }
        get containerMarginCss() {
            return this._containerMarginCss;
        }
        get containerLeftCss() {
            return this._containerLeftCss;
        }
        get containerHeight() {
            return this._containerHeight;
        }
        get containerHeightCss() {
            return this._containerHeightCss;
        }
        get containerBottomCss() {
            return this._containerBottomCss;
        }
        get stepCircleSize() {
            return this._stepCircleSize;
        }
        get stepCircleSizeCss() {
            return this._stepCircleSizeCss;
        }
        get stepCircleMarginCss() {
            return this._stepCircleMarginCss;
        }
        get turnCircleSize() {
            return this._turnCircleSize;
        }
        get turnCircleSizeCss() {
            return this._turnCircleSizeCss;
        }
        get outerRadius() {
            return this._outerRadius;
        }
        get innerRadius() {
            return this._innerRadius;
        }
        get shadowOffset() {
            return this._shadowOffset;
        }
        /**
         * Configures the min and max width values.
         *
         * @param {DirectionConfiguration} configuration Configuration
         * with min and max width values.
         */
        configure(configuration) {
            this._configure(configuration);
            this._reset();
        }
        /**
         * Resizes all properties according to the width and height
         * of the size object.
         *
         * @param {ViewportSize} size The size of the container element.
         */
        resize(size) {
            this._resize(size);
            this._reset();
        }
        /**
         * Calculates the coordinates on the unit circle for an angle.
         *
         * @param {number} angle Angle in radians.
         * @returns {Array<number>} The x and y coordinates on the unit circle.
         */
        angleToCoordinates(angle) {
            return [Math.cos(angle), Math.sin(angle)];
        }
        /**
         * Calculates the coordinates on the unit circle for the
         * relative angle between the first and second angle.
         *
         * @param {number} first Angle in radians.
         * @param {number} second Angle in radians.
         * @returns {Array<number>} The x and y coordinates on the unit circle
         * for the relative angle between the first and second angle.
         */
        relativeAngleToCoordiantes(first, second) {
            let relativeAngle = this._spatial.wrapAngle(first - second);
            return this.angleToCoordinates(relativeAngle);
        }
        _configure(configuration) {
            this._minWidth = configuration.minWidth;
            this._maxWidth = this._getMaxWidth(configuration.minWidth, configuration.maxWidth);
        }
        _resize(size) {
            this._elementWidth = size.width;
            this._elementHeight = size.height;
        }
        _reset() {
            this._containerWidth = this._getContainerWidth(this._elementWidth, this._elementHeight);
            this._containerHeight = this._getContainerHeight(this.containerWidth);
            this._stepCircleSize = this._getStepCircleDiameter(this._containerHeight);
            this._turnCircleSize = this._getTurnCircleDiameter(this.containerHeight);
            this._outerRadius = this._getOuterRadius(this._containerHeight);
            this._innerRadius = this._getInnerRadius(this._containerHeight);
            this._shadowOffset = 3;
            this._containerWidthCss = this._numberToCssPixels(this._containerWidth);
            this._containerMarginCss = this._numberToCssPixels(-0.5 * this._containerWidth);
            this._containerLeftCss = this._numberToCssPixels(Math.floor(0.5 * this._elementWidth));
            this._containerHeightCss = this._numberToCssPixels(this._containerHeight);
            this._containerBottomCss = this._numberToCssPixels(Math.floor(-0.08 * this._containerHeight));
            this._stepCircleSizeCss = this._numberToCssPixels(this._stepCircleSize);
            this._stepCircleMarginCss = this._numberToCssPixels(-0.5 * this._stepCircleSize);
            this._turnCircleSizeCss = this._numberToCssPixels(this._turnCircleSize);
        }
        _getContainerWidth(elementWidth, elementHeight) {
            let relativeWidth = (elementWidth - this._minThresholdWidth) / (this._maxThresholdWidth - this._minThresholdWidth);
            let relativeHeight = (elementHeight - this._minThresholdHeight) / (this._maxThresholdHeight - this._minThresholdHeight);
            let coeff = Math.max(0, Math.min(1, Math.min(relativeWidth, relativeHeight)));
            coeff = 0.04 * Math.round(25 * coeff);
            return this._minWidth + coeff * (this._maxWidth - this._minWidth);
        }
        _getContainerHeight(containerWidth) {
            return 0.77 * containerWidth;
        }
        _getStepCircleDiameter(containerHeight) {
            return 0.34 * containerHeight;
        }
        _getTurnCircleDiameter(containerHeight) {
            return 0.3 * containerHeight;
        }
        _getOuterRadius(containerHeight) {
            return 0.31 * containerHeight;
        }
        _getInnerRadius(containerHeight) {
            return 0.125 * containerHeight;
        }
        _numberToCssPixels(value) {
            return value + "px";
        }
        _getMaxWidth(value, minWidth) {
            return value > minWidth ? value : minWidth;
        }
    }

    /**
     * @class DirectionDOMRenderer
     * @classdesc DOM renderer for direction arrows.
     */
    class DirectionDOMRenderer {
        constructor(configuration, size) {
            this._isEdge = false;
            this._spatial = new Spatial();
            this._calculator = new DirectionDOMCalculator(configuration, size);
            this._image = null;
            this._rotation = { phi: 0, theta: 0 };
            this._epsilon = 0.5 * Math.PI / 180;
            this._highlightKey = null;
            this._distinguishSequence = false;
            this._needsRender = false;
            this._stepEdges = [];
            this._turnEdges = [];
            this._sphericalEdges = [];
            this._sequenceEdgeKeys = [];
            this._stepDirections = [
                exports.NavigationDirection.StepForward,
                exports.NavigationDirection.StepBackward,
                exports.NavigationDirection.StepLeft,
                exports.NavigationDirection.StepRight,
            ];
            this._turnDirections = [
                exports.NavigationDirection.TurnLeft,
                exports.NavigationDirection.TurnRight,
                exports.NavigationDirection.TurnU,
            ];
            this._turnNames = {};
            this._turnNames[exports.NavigationDirection.TurnLeft] = "mapillary-direction-turn-left";
            this._turnNames[exports.NavigationDirection.TurnRight] = "mapillary-direction-turn-right";
            this._turnNames[exports.NavigationDirection.TurnU] = "mapillary-direction-turn-around";
            // detects IE 8-11, then Edge 20+.
            let isIE = !!document.documentMode;
            this._isEdge = !isIE && !!window.StyleMedia;
        }
        /**
         * Get needs render.
         *
         * @returns {boolean} Value indicating whether render should be called.
         */
        get needsRender() {
            return this._needsRender;
        }
        /**
         * Renders virtual DOM elements.
         *
         * @description Calling render resets the needs render property.
         */
        render(navigator) {
            this._needsRender = false;
            let rotation = this._rotation;
            let steps = [];
            let turns = [];
            if (isSpherical(this._image.cameraType)) {
                steps = steps.concat(this._createSphericalArrows(navigator, rotation));
            }
            else {
                steps = steps.concat(this._createPerspectiveToSphericalArrows(navigator, rotation));
                steps = steps.concat(this._createStepArrows(navigator, rotation));
                turns = turns.concat(this._createTurnArrows(navigator));
            }
            return this._getContainer(steps, turns, rotation);
        }
        setEdges(edgeStatus, sequence) {
            this._setEdges(edgeStatus, sequence);
            this._setNeedsRender();
        }
        /**
         * Set image for which to show edges.
         *
         * @param {Image} image
         */
        setImage(image) {
            this._image = image;
            this._clearEdges();
            this._setNeedsRender();
        }
        /**
         * Set the render camera to use for calculating rotations.
         *
         * @param {RenderCamera} renderCamera
         */
        setRenderCamera(renderCamera) {
            let rotation = renderCamera.rotation;
            if (Math.abs(rotation.phi - this._rotation.phi) < this._epsilon) {
                return;
            }
            this._rotation = rotation;
            this._setNeedsRender();
        }
        /**
         * Set configuration values.
         *
         * @param {DirectionConfiguration} configuration
         */
        setConfiguration(configuration) {
            let needsRender = false;
            if (this._highlightKey !== configuration.highlightId ||
                this._distinguishSequence !== configuration.distinguishSequence) {
                this._highlightKey = configuration.highlightId;
                this._distinguishSequence = configuration.distinguishSequence;
                needsRender = true;
            }
            if (this._calculator.minWidth !== configuration.minWidth ||
                this._calculator.maxWidth !== configuration.maxWidth) {
                this._calculator.configure(configuration);
                needsRender = true;
            }
            if (needsRender) {
                this._setNeedsRender();
            }
        }
        /**
         * Detect the element's width and height and resize
         * elements accordingly.
         *
         * @param {ViewportSize} size Size of vßiewer container element.
         */
        resize(size) {
            this._calculator.resize(size);
            this._setNeedsRender();
        }
        _setNeedsRender() {
            if (this._image != null) {
                this._needsRender = true;
            }
        }
        _clearEdges() {
            this._stepEdges = [];
            this._turnEdges = [];
            this._sphericalEdges = [];
            this._sequenceEdgeKeys = [];
        }
        _setEdges(edgeStatus, sequence) {
            this._stepEdges = [];
            this._turnEdges = [];
            this._sphericalEdges = [];
            this._sequenceEdgeKeys = [];
            for (let edge of edgeStatus.edges) {
                let direction = edge.data.direction;
                if (this._stepDirections.indexOf(direction) > -1) {
                    this._stepEdges.push(edge);
                    continue;
                }
                if (this._turnDirections.indexOf(direction) > -1) {
                    this._turnEdges.push(edge);
                    continue;
                }
                if (edge.data.direction === exports.NavigationDirection.Spherical) {
                    this._sphericalEdges.push(edge);
                }
            }
            if (this._distinguishSequence && sequence != null) {
                let edges = this._sphericalEdges
                    .concat(this._stepEdges)
                    .concat(this._turnEdges);
                for (let edge of edges) {
                    let edgeKey = edge.target;
                    for (let sequenceKey of sequence.imageIds) {
                        if (sequenceKey === edgeKey) {
                            this._sequenceEdgeKeys.push(edgeKey);
                            break;
                        }
                    }
                }
            }
        }
        _createSphericalArrows(navigator, rotation) {
            let arrows = [];
            for (let sphericalEdge of this._sphericalEdges) {
                arrows.push(this._createVNodeByKey(navigator, sphericalEdge.target, sphericalEdge.data.worldMotionAzimuth, rotation, this._calculator.outerRadius, "mapillary-direction-arrow-spherical"));
            }
            for (let stepEdge of this._stepEdges) {
                arrows.push(this._createSphericalToPerspectiveArrow(navigator, stepEdge.target, stepEdge.data.worldMotionAzimuth, rotation, stepEdge.data.direction));
            }
            return arrows;
        }
        _createSphericalToPerspectiveArrow(navigator, key, azimuth, rotation, direction) {
            let threshold = Math.PI / 8;
            let relativePhi = rotation.phi;
            switch (direction) {
                case exports.NavigationDirection.StepBackward:
                    relativePhi = rotation.phi - Math.PI;
                    break;
                case exports.NavigationDirection.StepLeft:
                    relativePhi = rotation.phi + Math.PI / 2;
                    break;
                case exports.NavigationDirection.StepRight:
                    relativePhi = rotation.phi - Math.PI / 2;
                    break;
            }
            if (Math.abs(this._spatial.wrapAngle(azimuth - relativePhi)) < threshold) {
                return this._createVNodeByKey(navigator, key, azimuth, rotation, this._calculator.outerRadius, "mapillary-direction-arrow-step");
            }
            return this._createVNodeInactive(key, azimuth, rotation);
        }
        _createPerspectiveToSphericalArrows(navigator, rotation) {
            let arrows = [];
            for (let sphericalEdge of this._sphericalEdges) {
                arrows.push(this._createVNodeByKey(navigator, sphericalEdge.target, sphericalEdge.data.worldMotionAzimuth, rotation, this._calculator.innerRadius, "mapillary-direction-arrow-spherical", true));
            }
            return arrows;
        }
        _createStepArrows(navigator, rotation) {
            let arrows = [];
            for (let stepEdge of this._stepEdges) {
                arrows.push(this._createVNodeByDirection(navigator, stepEdge.target, stepEdge.data.worldMotionAzimuth, rotation, stepEdge.data.direction));
            }
            return arrows;
        }
        _createTurnArrows(navigator) {
            let turns = [];
            for (let turnEdge of this._turnEdges) {
                let direction = turnEdge.data.direction;
                let name = this._turnNames[direction];
                turns.push(this._createVNodeByTurn(navigator, turnEdge.target, name, direction));
            }
            return turns;
        }
        _createVNodeByKey(navigator, key, azimuth, rotation, offset, className, shiftVertically) {
            let onClick = (e) => {
                navigator.moveTo$(key)
                    .subscribe(undefined, (error) => {
                    if (!(error instanceof CancelMapillaryError)) {
                        console.error(error);
                    }
                });
            };
            return this._createVNode(key, azimuth, rotation, offset, className, "mapillary-direction-circle", onClick, shiftVertically);
        }
        _createVNodeByDirection(navigator, key, azimuth, rotation, direction) {
            let onClick = (e) => {
                navigator.moveDir$(direction)
                    .subscribe(undefined, (error) => {
                    if (!(error instanceof CancelMapillaryError)) {
                        console.error(error);
                    }
                });
            };
            return this._createVNode(key, azimuth, rotation, this._calculator.outerRadius, "mapillary-direction-arrow-step", "mapillary-direction-circle", onClick);
        }
        _createVNodeByTurn(navigator, key, className, direction) {
            let onClick = (e) => {
                navigator.moveDir$(direction)
                    .subscribe(undefined, (error) => {
                    if (!(error instanceof CancelMapillaryError)) {
                        console.error(error);
                    }
                });
            };
            let style = {
                height: this._calculator.turnCircleSizeCss,
                transform: "rotate(0)",
                width: this._calculator.turnCircleSizeCss,
            };
            switch (direction) {
                case exports.NavigationDirection.TurnLeft:
                    style.left = "5px";
                    style.top = "5px";
                    break;
                case exports.NavigationDirection.TurnRight:
                    style.right = "5px";
                    style.top = "5px";
                    break;
                case exports.NavigationDirection.TurnU:
                    style.left = "5px";
                    style.bottom = "5px";
                    break;
            }
            let circleProperties = {
                attributes: {
                    "data-id": key,
                },
                onclick: onClick,
                style: style,
            };
            let circleClassName = "mapillary-direction-turn-circle";
            if (this._sequenceEdgeKeys.indexOf(key) > -1) {
                circleClassName += "-sequence";
            }
            if (this._highlightKey === key) {
                circleClassName += "-highlight";
            }
            let turn = virtualDom.h(`div.${className}`, {}, []);
            return virtualDom.h("div." + circleClassName, circleProperties, [turn]);
        }
        _createVNodeInactive(key, azimuth, rotation) {
            return this._createVNode(key, azimuth, rotation, this._calculator.outerRadius, "mapillary-direction-arrow-inactive", "mapillary-direction-circle-inactive");
        }
        _createVNode(key, azimuth, rotation, radius, className, circleClassName, onClick, shiftVertically) {
            let translation = this._calculator.angleToCoordinates(azimuth - rotation.phi);
            // rotate 90 degrees clockwise and flip over X-axis
            let translationX = Math.round(-radius * translation[1] + 0.5 * this._calculator.containerWidth);
            let translationY = Math.round(-radius * translation[0] + 0.5 * this._calculator.containerHeight);
            let shadowTranslation = this._calculator.relativeAngleToCoordiantes(azimuth, rotation.phi);
            let shadowOffset = this._calculator.shadowOffset;
            let shadowTranslationX = -shadowOffset * shadowTranslation[1];
            let shadowTranslationY = shadowOffset * shadowTranslation[0];
            let filter = `drop-shadow(${shadowTranslationX}px ${shadowTranslationY}px 1px rgba(0,0,0,0.8))`;
            let properties = {
                style: {
                    "-webkit-filter": filter,
                    filter: filter,
                },
            };
            let chevron = virtualDom.h("div." + className, properties, []);
            let azimuthDeg = -this._spatial.radToDeg(azimuth - rotation.phi);
            let circleTransform = shiftVertically ?
                `translate(${translationX}px, ${translationY}px) rotate(${azimuthDeg}deg) translateZ(-0.01px)` :
                `translate(${translationX}px, ${translationY}px) rotate(${azimuthDeg}deg)`;
            let circleProperties = {
                attributes: { "data-id": key },
                onclick: onClick,
                style: {
                    height: this._calculator.stepCircleSizeCss,
                    marginLeft: this._calculator.stepCircleMarginCss,
                    marginTop: this._calculator.stepCircleMarginCss,
                    transform: circleTransform,
                    width: this._calculator.stepCircleSizeCss,
                },
            };
            if (this._sequenceEdgeKeys.indexOf(key) > -1) {
                circleClassName += "-sequence";
            }
            if (this._highlightKey === key) {
                circleClassName += "-highlight";
            }
            return virtualDom.h("div." + circleClassName, circleProperties, [chevron]);
        }
        _getContainer(steps, turns, rotation) {
            // edge does not handle hover on perspective transforms.
            let transform = this._isEdge ?
                "rotateX(60deg)" :
                `perspective(${this._calculator.containerWidthCss}) rotateX(60deg)`;
            let properties = {
                oncontextmenu: (event) => { event.preventDefault(); },
                style: {
                    bottom: this._calculator.containerBottomCss,
                    height: this._calculator.containerHeightCss,
                    left: this._calculator.containerLeftCss,
                    marginLeft: this._calculator.containerMarginCss,
                    transform: transform,
                    width: this._calculator.containerWidthCss,
                },
            };
            return virtualDom.h("div.mapillary-direction-perspective", properties, turns.concat(steps));
        }
    }

    /**
     * @class DirectionComponent
     * @classdesc Component showing navigation arrows for steps and turns.
     */
    class DirectionComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator, directionDOMRenderer) {
            super(name, container, navigator);
            this._renderer = !!directionDOMRenderer ?
                directionDOMRenderer :
                new DirectionDOMRenderer(this.defaultConfiguration, { height: container.container.offsetHeight, width: container.container.offsetWidth });
            this._hoveredIdSubject$ = new Subject();
            this._hoveredId$ = this._hoveredIdSubject$.pipe(share());
        }
        fire(type, event) {
            super.fire(type, event);
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        _activate() {
            const subs = this._subscriptions;
            subs.push(this._configuration$
                .subscribe((configuration) => {
                this._renderer.setConfiguration(configuration);
            }));
            subs.push(this._container.renderService.size$
                .subscribe((size) => {
                this._renderer.resize(size);
            }));
            subs.push(this._navigator.stateService.currentImage$.pipe(tap((image) => {
                this._container.domRenderer.render$.next({ name: this._name, vNode: virtualDom.h("div", {}, []) });
                this._renderer.setImage(image);
            }), withLatestFrom(this._configuration$), switchMap(([image, configuration]) => {
                return combineLatest(image.spatialEdges$, configuration.distinguishSequence ?
                    this._navigator.graphService
                        .cacheSequence$(image.sequenceId).pipe(catchError((error) => {
                        console.error(`Failed to cache sequence (${image.sequenceId})`, error);
                        return of(null);
                    })) :
                    of(null));
            }))
                .subscribe(([edgeStatus, sequence]) => {
                this._renderer.setEdges(edgeStatus, sequence);
            }));
            subs.push(this._container.renderService.renderCameraFrame$.pipe(tap((renderCamera) => {
                this._renderer.setRenderCamera(renderCamera);
            }), map(() => {
                return this._renderer;
            }), filter((renderer) => {
                return renderer.needsRender;
            }), map((renderer) => {
                return { name: this._name, vNode: renderer.render(this._navigator) };
            }))
                .subscribe(this._container.domRenderer.render$));
            subs.push(combineLatest(this._container.domRenderer.element$, this._container.renderService.renderCamera$, this._container.mouseService.mouseMove$.pipe(startWith(null)), this._container.mouseService.mouseUp$.pipe(startWith(null))).pipe(map(([element]) => {
                let elements = element.getElementsByClassName("mapillary-direction-perspective");
                for (let i = 0; i < elements.length; i++) {
                    let hovered = elements.item(i).querySelector(":hover");
                    if (hovered != null && hovered.hasAttribute("data-id")) {
                        return hovered.getAttribute("data-id");
                    }
                }
                return null;
            }), distinctUntilChanged())
                .subscribe(this._hoveredIdSubject$));
            subs.push(this._hoveredId$
                .subscribe((id) => {
                const type = "hover";
                const event = {
                    id,
                    target: this,
                    type,
                };
                this.fire(type, event);
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return {
                distinguishSequence: false,
                maxWidth: 460,
                minWidth: 260,
            };
        }
    }
    /** @inheritdoc */
    DirectionComponent.componentName = "direction";

    const sphericalFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

#define tau 6.28318530718

uniform sampler2D projectorTex;
uniform float opacity;

varying vec4 vRstq;

void main()
{
    vec3 b = normalize(vRstq.xyz);
    float lat = -asin(b.y);
    float lng = atan(b.x, b.z);
    float x = lng / tau + 0.5;
    float y = lat / tau * 2.0 + 0.5;
    vec4 baseColor = texture2D(projectorTex, vec2(x, y));
    baseColor.a = opacity;
    gl_FragColor = baseColor;
}
`;

    const sphericalVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const sphericalCurtainFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

#define tau 6.28318530718

uniform sampler2D projectorTex;
uniform float curtain;
uniform float opacity;

varying vec4 vRstq;

void main()
{
    vec3 b = normalize(vRstq.xyz);
    float lat = -asin(b.y);
    float lng = atan(b.x, b.z);
    float x = lng / tau + 0.5;
    float y = lat / tau * 2.0 + 0.5;

    bool inverted = curtain < 0.5;

    float curtainMin = inverted ? curtain + 0.5 : curtain - 0.5;
    float curtainMax = curtain;

    bool insideCurtain = inverted ?
        x > curtainMin || x < curtainMax :
        x > curtainMin && x < curtainMax;

    vec4 baseColor;
    if (insideCurtain) {
        baseColor = texture2D(projectorTex, vec2(x, y));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const sphericalCurtainVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const fisheyeFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

uniform sampler2D projectorTex;
uniform float opacity;
uniform float focal;
uniform float k1;
uniform float k2;
uniform float scale_x;
uniform float scale_y;
uniform float radial_peak;

varying vec4 vRstq;

void main()
{
    float x = vRstq.x;
    float y = vRstq.y;
    float z = vRstq.z;

    float r = sqrt(x * x + y * y);
    float theta = atan(r, z);

    if (radial_peak > 0. && theta > radial_peak) {
        theta = radial_peak;
    }

    float theta2 = theta * theta;
    float theta_d = theta * (1.0 + theta2 * (k1 + theta2 * k2));
    float s = focal * theta_d / r;

    float u = scale_x * s * x + 0.5;
    float v = -scale_y * s * y + 0.5;

    vec4 baseColor;
    if (u >= 0. && u <= 1. && v >= 0. && v <= 1.) {
        baseColor = texture2D(projectorTex, vec2(u, v));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const fisheyeVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const fisheyeCurtainFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

uniform sampler2D projectorTex;
uniform float opacity;
uniform float focal;
uniform float k1;
uniform float k2;
uniform float scale_x;
uniform float scale_y;
uniform float radial_peak;
uniform float curtain;

varying vec4 vRstq;

void main()
{
    float x = vRstq.x;
    float y = vRstq.y;
    float z = vRstq.z;

    float r2 = sqrt(x * x + y * y);
    float theta = atan(r2, z);

    if (radial_peak > 0. && theta > radial_peak) {
        theta = radial_peak;
    }

    float theta2 = theta * theta;
    float theta_d = theta * (1.0 + theta2 * (k1 + theta2 * k2));
    float s = focal * theta_d / r2;

    float u = scale_x * s * x + 0.5;
    float v = -scale_y * s * y + 0.5;

    vec4 baseColor;
    if ((u < curtain || curtain >= 1.0) && u >= 0. && u <= 1. && v >= 0. && v <= 1.) {
        baseColor = texture2D(projectorTex, vec2(u, v));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const fisheyeCurtainVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const perspectiveFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

uniform sampler2D projectorTex;
uniform float opacity;
uniform float focal;
uniform float k1;
uniform float k2;
uniform float scale_x;
uniform float scale_y;
uniform float radial_peak;

varying vec4 vRstq;

void main()
{
    float x = vRstq.x / vRstq.z;
    float y = vRstq.y / vRstq.z;
    float r2 = x * x + y * y;

    if (radial_peak > 0. && r2 > radial_peak * sqrt(r2)) {
        r2 = radial_peak * radial_peak;
    }

    float d = 1.0 + k1 * r2 + k2 * r2 * r2;
    float u = scale_x * focal * d * x + 0.5;
    float v = - scale_y * focal * d * y + 0.5;

    vec4 baseColor;
    if (u >= 0. && u <= 1. && v >= 0. && v <= 1.) {
        baseColor = texture2D(projectorTex, vec2(u, v));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const perspectiveVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const perspectiveCurtainFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

uniform sampler2D projectorTex;
uniform float opacity;
uniform float focal;
uniform float k1;
uniform float k2;
uniform float scale_x;
uniform float scale_y;
uniform float radial_peak;
uniform float curtain;

varying vec4 vRstq;

void main()
{
    float x = vRstq.x / vRstq.z;
    float y = vRstq.y / vRstq.z;
    float r2 = x * x + y * y;

    if (radial_peak > 0. && r2 > radial_peak * sqrt(r2)) {
        r2 = radial_peak * radial_peak;
    }

    float d = 1.0 + k1 * r2 + k2 * r2 * r2;
    float u = scale_x * focal * d * x + 0.5;
    float v = - scale_y * focal * d * y + 0.5;

    vec4 baseColor;
    if ((u < curtain || curtain >= 1.0) && u >= 0. && u <= 1. && v >= 0. && v <= 1.) {
        baseColor = texture2D(projectorTex, vec2(u, v));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const perspectiveCurtainVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const perspectiveDistortedFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

uniform sampler2D projectorTex;
uniform float opacity;

varying vec4 vRstq;

void main()
{
    float u = vRstq.x / vRstq.w;
    float v = vRstq.y / vRstq.w;

    vec4 baseColor;
    if (u >= 0. && u <= 1. && v >= 0. && v <= 1.) {
        baseColor = texture2D(projectorTex, vec2(u, v));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const perspectiveDistortedVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    const perspectiveDistortedCurtainFrag = `
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif

uniform sampler2D projectorTex;
uniform float opacity;
uniform float curtain;

varying vec4 vRstq;

void main()
{
    float u = vRstq.x / vRstq.w;
    float v = vRstq.y / vRstq.w;

    vec4 baseColor;
    if ((u < curtain || curtain >= 1.0) && u >= 0. && u <= 1. && v >= 0. && v <= 1.) {
        baseColor = texture2D(projectorTex, vec2(u, v));
        baseColor.a = opacity;
    } else {
        baseColor = vec4(0.0, 0.0, 0.0, 0.0);
    }

    gl_FragColor = baseColor;
}
`;

    const perspectiveDistortedCurtainVert = `
#ifdef GL_ES
precision highp float;
#endif

uniform mat4 projectorMat;

varying vec4 vRstq;

void main()
{
    vRstq = projectorMat * vec4(position, 1.0);
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;

    class Shaders {
    }
    Shaders.fisheye = {
        fragment: fisheyeFrag,
        vertex: fisheyeVert,
    };
    Shaders.fisheyeCurtain = {
        fragment: fisheyeCurtainFrag,
        vertex: fisheyeCurtainVert,
    };
    Shaders.perspective = {
        fragment: perspectiveFrag,
        vertex: perspectiveVert,
    };
    Shaders.perspectiveCurtain = {
        fragment: perspectiveCurtainFrag,
        vertex: perspectiveCurtainVert,
    };
    Shaders.perspectiveDistorted = {
        fragment: perspectiveDistortedFrag,
        vertex: perspectiveDistortedVert,
    };
    Shaders.perspectiveDistortedCurtain = {
        fragment: perspectiveDistortedCurtainFrag,
        vertex: perspectiveDistortedCurtainVert,
    };
    Shaders.spherical = {
        fragment: sphericalFrag,
        vertex: sphericalVert,
    };
    Shaders.sphericalCurtain = {
        fragment: sphericalCurtainFrag,
        vertex: sphericalCurtainVert,
    };

    class MeshFactory {
        constructor(imagePlaneDepth, imageSphereRadius) {
            this._imagePlaneDepth = imagePlaneDepth != null ? imagePlaneDepth : 200;
            this._imageSphereRadius = imageSphereRadius != null ? imageSphereRadius : 200;
        }
        createMesh(image, transform) {
            if (isSpherical(transform.cameraType)) {
                return this._createImageSphere(image, transform);
            }
            else if (isFisheye(transform.cameraType)) {
                return this._createImagePlaneFisheye(image, transform);
            }
            else {
                return this._createImagePlane(image, transform);
            }
        }
        createFlatMesh(image, transform, basicX0, basicX1, basicY0, basicY1) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createDistortedPlaneMaterialParameters(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let geometry = this._getFlatImagePlaneGeoFromBasic(transform, basicX0, basicX1, basicY0, basicY1);
            return new Mesh(geometry, material);
        }
        createCurtainMesh(image, transform) {
            if (isSpherical(transform.cameraType)) {
                return this._createSphereCurtainMesh(image, transform);
            }
            else if (isFisheye(transform.cameraType)) {
                return this._createCurtainMeshFisheye(image, transform);
            }
            else {
                return this._createCurtainMesh(image, transform);
            }
        }
        createDistortedCurtainMesh(image, transform) {
            return this._createDistortedCurtainMesh(image, transform);
        }
        _createCurtainMesh(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createCurtainPlaneMaterialParameters(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let geometry = this._useMesh(transform, image) ?
                this._getImagePlaneGeo(transform, image) :
                this._getRegularFlatImagePlaneGeo(transform);
            return new Mesh(geometry, material);
        }
        _createCurtainMeshFisheye(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createCurtainPlaneMaterialParametersFisheye(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let geometry = this._useMesh(transform, image) ?
                this._getImagePlaneGeoFisheye(transform, image) :
                this._getRegularFlatImagePlaneGeo(transform);
            return new Mesh(geometry, material);
        }
        _createDistortedCurtainMesh(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createDistortedCurtainPlaneMaterialParameters(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let geometry = this._getRegularFlatImagePlaneGeo(transform);
            return new Mesh(geometry, material);
        }
        _createSphereCurtainMesh(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createCurtainSphereMaterialParameters(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            return this._useMesh(transform, image) ?
                new Mesh(this._getImageSphereGeo(transform, image), material) :
                new Mesh(this._getFlatImageSphereGeo(transform), material);
        }
        _createImageSphere(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createSphereMaterialParameters(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let mesh = this._useMesh(transform, image) ?
                new Mesh(this._getImageSphereGeo(transform, image), material) :
                new Mesh(this._getFlatImageSphereGeo(transform), material);
            return mesh;
        }
        _createImagePlane(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createPlaneMaterialParameters(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let geometry = this._useMesh(transform, image) ?
                this._getImagePlaneGeo(transform, image) :
                this._getRegularFlatImagePlaneGeo(transform);
            return new Mesh(geometry, material);
        }
        _createImagePlaneFisheye(image, transform) {
            let texture = this._createTexture(image.image);
            let materialParameters = this._createPlaneMaterialParametersFisheye(transform, texture);
            let material = new ShaderMaterial(materialParameters);
            let geometry = this._useMesh(transform, image) ?
                this._getImagePlaneGeoFisheye(transform, image) :
                this._getRegularFlatImagePlaneGeoFisheye(transform);
            return new Mesh(geometry, material);
        }
        _createSphereMaterialParameters(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.spherical.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.rt },
                    projectorTex: { value: texture },
                },
                vertexShader: Shaders.spherical.vertex,
            };
            return materialParameters;
        }
        _createCurtainSphereMaterialParameters(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.sphericalCurtain.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    curtain: { value: 1.0 },
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.rt },
                    projectorTex: { value: texture },
                },
                vertexShader: Shaders.sphericalCurtain.vertex,
            };
            return materialParameters;
        }
        _createPlaneMaterialParameters(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.perspective.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    focal: { value: transform.focal },
                    k1: { value: transform.ck1 },
                    k2: { value: transform.ck2 },
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.basicRt },
                    projectorTex: { value: texture },
                    radial_peak: { value: !!transform.radialPeak ? transform.radialPeak : 0.0 },
                    scale_x: { value: Math.max(transform.basicHeight, transform.basicWidth) / transform.basicWidth },
                    scale_y: { value: Math.max(transform.basicWidth, transform.basicHeight) / transform.basicHeight },
                },
                vertexShader: Shaders.perspective.vertex,
            };
            return materialParameters;
        }
        _createPlaneMaterialParametersFisheye(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.fisheye.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    focal: { value: transform.focal },
                    k1: { value: transform.ck1 },
                    k2: { value: transform.ck2 },
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.basicRt },
                    projectorTex: { value: texture },
                    radial_peak: { value: !!transform.radialPeak ? transform.radialPeak : 0.0 },
                    scale_x: { value: Math.max(transform.basicHeight, transform.basicWidth) / transform.basicWidth },
                    scale_y: { value: Math.max(transform.basicWidth, transform.basicHeight) / transform.basicHeight },
                },
                vertexShader: Shaders.fisheye.vertex,
            };
            return materialParameters;
        }
        _createCurtainPlaneMaterialParametersFisheye(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.fisheyeCurtain.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    curtain: { value: 1.0 },
                    focal: { value: transform.focal },
                    k1: { value: transform.ck1 },
                    k2: { value: transform.ck2 },
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.basicRt },
                    projectorTex: { value: texture },
                    radial_peak: { value: !!transform.radialPeak ? transform.radialPeak : 0.0 },
                    scale_x: { value: Math.max(transform.basicHeight, transform.basicWidth) / transform.basicWidth },
                    scale_y: { value: Math.max(transform.basicWidth, transform.basicHeight) / transform.basicHeight },
                },
                vertexShader: Shaders.fisheyeCurtain.vertex,
            };
            return materialParameters;
        }
        _createCurtainPlaneMaterialParameters(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.perspectiveCurtain.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    curtain: { value: 1.0 },
                    focal: { value: transform.focal },
                    k1: { value: transform.ck1 },
                    k2: { value: transform.ck2 },
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.basicRt },
                    projectorTex: { value: texture },
                    radial_peak: { value: !!transform.radialPeak ? transform.radialPeak : 0.0 },
                    scale_x: { value: Math.max(transform.basicHeight, transform.basicWidth) / transform.basicWidth },
                    scale_y: { value: Math.max(transform.basicWidth, transform.basicHeight) / transform.basicHeight },
                },
                vertexShader: Shaders.perspectiveCurtain.vertex,
            };
            return materialParameters;
        }
        _createDistortedCurtainPlaneMaterialParameters(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.perspectiveDistortedCurtain.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    curtain: { value: 1.0 },
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.projectorMatrix() },
                    projectorTex: { value: texture },
                },
                vertexShader: Shaders.perspectiveDistortedCurtain.vertex,
            };
            return materialParameters;
        }
        _createDistortedPlaneMaterialParameters(transform, texture) {
            let materialParameters = {
                depthWrite: false,
                fragmentShader: Shaders.perspectiveDistorted.fragment,
                side: DoubleSide,
                transparent: true,
                uniforms: {
                    opacity: { value: 1.0 },
                    projectorMat: { value: transform.projectorMatrix() },
                    projectorTex: { value: texture },
                },
                vertexShader: Shaders.perspectiveDistorted.vertex,
            };
            return materialParameters;
        }
        _createTexture(image) {
            let texture = new Texture(image);
            texture.minFilter = LinearFilter;
            texture.needsUpdate = true;
            return texture;
        }
        _useMesh(transform, image) {
            return image.mesh.vertices.length && transform.hasValidScale;
        }
        _getImageSphereGeo(transform, image) {
            const t = transform.srtInverse;
            // push everything at least 5 meters in front of the camera
            let minZ = 5.0 * transform.scale;
            let maxZ = this._imageSphereRadius * transform.scale;
            let vertices = image.mesh.vertices;
            let numVertices = vertices.length / 3;
            let positions = new Float32Array(vertices.length);
            for (let i = 0; i < numVertices; ++i) {
                let index = 3 * i;
                let x = vertices[index + 0];
                let y = vertices[index + 1];
                let z = vertices[index + 2];
                let l = Math.sqrt(x * x + y * y + z * z);
                let boundedL = Math.max(minZ, Math.min(l, maxZ));
                let factor = boundedL / l;
                let p = new Vector3(x * factor, y * factor, z * factor);
                p.applyMatrix4(t);
                positions[index + 0] = p.x;
                positions[index + 1] = p.y;
                positions[index + 2] = p.z;
            }
            let faces = image.mesh.faces;
            let indices = new Uint16Array(faces.length);
            for (let i = 0; i < faces.length; ++i) {
                indices[i] = faces[i];
            }
            let geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            geometry.setIndex(new BufferAttribute(indices, 1));
            return geometry;
        }
        _getImagePlaneGeo(transform, image) {
            const undistortionMarginFactor = 3;
            const t = transform.srtInverse;
            // push everything at least 5 meters in front of the camera
            let minZ = 5.0 * transform.scale;
            let maxZ = this._imagePlaneDepth * transform.scale;
            let vertices = image.mesh.vertices;
            let numVertices = vertices.length / 3;
            let positions = new Float32Array(vertices.length);
            for (let i = 0; i < numVertices; ++i) {
                let index = 3 * i;
                let x = vertices[index + 0];
                let y = vertices[index + 1];
                let z = vertices[index + 2];
                if (i < 4) {
                    x *= undistortionMarginFactor;
                    y *= undistortionMarginFactor;
                }
                let boundedZ = Math.max(minZ, Math.min(z, maxZ));
                let factor = boundedZ / z;
                let p = new Vector3(x * factor, y * factor, boundedZ);
                p.applyMatrix4(t);
                positions[index + 0] = p.x;
                positions[index + 1] = p.y;
                positions[index + 2] = p.z;
            }
            let faces = image.mesh.faces;
            let indices = new Uint16Array(faces.length);
            for (let i = 0; i < faces.length; ++i) {
                indices[i] = faces[i];
            }
            let geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            geometry.setIndex(new BufferAttribute(indices, 1));
            return geometry;
        }
        _getImagePlaneGeoFisheye(transform, image) {
            const t = transform.srtInverse;
            // push everything at least 5 meters in front of the camera
            let minZ = 5.0 * transform.scale;
            let maxZ = this._imagePlaneDepth * transform.scale;
            let vertices = image.mesh.vertices;
            let numVertices = vertices.length / 3;
            let positions = new Float32Array(vertices.length);
            for (let i = 0; i < numVertices; ++i) {
                let index = 3 * i;
                let x = vertices[index + 0];
                let y = vertices[index + 1];
                let z = vertices[index + 2];
                let l = Math.sqrt(x * x + y * y + z * z);
                let boundedL = Math.max(minZ, Math.min(l, maxZ));
                let factor = boundedL / l;
                let p = new Vector3(x * factor, y * factor, z * factor);
                p.applyMatrix4(t);
                positions[index + 0] = p.x;
                positions[index + 1] = p.y;
                positions[index + 2] = p.z;
            }
            let faces = image.mesh.faces;
            let indices = new Uint16Array(faces.length);
            for (let i = 0; i < faces.length; ++i) {
                indices[i] = faces[i];
            }
            let geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            geometry.setIndex(new BufferAttribute(indices, 1));
            return geometry;
        }
        _getFlatImageSphereGeo(transform) {
            const geometry = new SphereGeometry(this._imageSphereRadius, 20, 40);
            const t = transform.rt
                .clone()
                .invert();
            geometry.applyMatrix4(t);
            return geometry;
        }
        _getRegularFlatImagePlaneGeo(transform) {
            let width = transform.width;
            let height = transform.height;
            let size = Math.max(width, height);
            let dx = width / 2.0 / size;
            let dy = height / 2.0 / size;
            return this._getFlatImagePlaneGeo(transform, dx, dy);
        }
        _getFlatImagePlaneGeo(transform, dx, dy) {
            let vertices = [];
            vertices.push(transform.unprojectSfM([-dx, -dy], this._imagePlaneDepth));
            vertices.push(transform.unprojectSfM([dx, -dy], this._imagePlaneDepth));
            vertices.push(transform.unprojectSfM([dx, dy], this._imagePlaneDepth));
            vertices.push(transform.unprojectSfM([-dx, dy], this._imagePlaneDepth));
            return this._createFlatGeometry(vertices);
        }
        _getRegularFlatImagePlaneGeoFisheye(transform) {
            let width = transform.width;
            let height = transform.height;
            let size = Math.max(width, height);
            let dx = width / 2.0 / size;
            let dy = height / 2.0 / size;
            return this._getFlatImagePlaneGeoFisheye(transform, dx, dy);
        }
        _getFlatImagePlaneGeoFisheye(transform, dx, dy) {
            let vertices = [];
            vertices.push(transform.unprojectSfM([-dx, -dy], this._imagePlaneDepth));
            vertices.push(transform.unprojectSfM([dx, -dy], this._imagePlaneDepth));
            vertices.push(transform.unprojectSfM([dx, dy], this._imagePlaneDepth));
            vertices.push(transform.unprojectSfM([-dx, dy], this._imagePlaneDepth));
            return this._createFlatGeometry(vertices);
        }
        _getFlatImagePlaneGeoFromBasic(transform, basicX0, basicX1, basicY0, basicY1) {
            let vertices = [];
            vertices.push(transform.unprojectBasic([basicX0, basicY0], this._imagePlaneDepth));
            vertices.push(transform.unprojectBasic([basicX1, basicY0], this._imagePlaneDepth));
            vertices.push(transform.unprojectBasic([basicX1, basicY1], this._imagePlaneDepth));
            vertices.push(transform.unprojectBasic([basicX0, basicY1], this._imagePlaneDepth));
            return this._createFlatGeometry(vertices);
        }
        _createFlatGeometry(vertices) {
            let positions = new Float32Array(12);
            for (let i = 0; i < vertices.length; i++) {
                let index = 3 * i;
                positions[index + 0] = vertices[i][0];
                positions[index + 1] = vertices[i][1];
                positions[index + 2] = vertices[i][2];
            }
            let indices = new Uint16Array(6);
            indices[0] = 0;
            indices[1] = 1;
            indices[2] = 3;
            indices[3] = 1;
            indices[4] = 2;
            indices[5] = 3;
            let geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            geometry.setIndex(new BufferAttribute(indices, 1));
            return geometry;
        }
    }

    class MeshScene {
        constructor() {
            this._planes = {};
            this._planesOld = {};
            this._planesPeriphery = {};
            this._scene = new Scene();
            this._sceneOld = new Scene();
            this._scenePeriphery = new Scene();
        }
        get planes() {
            return this._planes;
        }
        get planesOld() {
            return this._planesOld;
        }
        get planesPeriphery() {
            return this._planesPeriphery;
        }
        get scene() {
            return this._scene;
        }
        get sceneOld() {
            return this._sceneOld;
        }
        get scenePeriphery() {
            return this._scenePeriphery;
        }
        updateImagePlanes(planes) {
            this._dispose(this._planesOld, this.sceneOld);
            for (const key in this._planes) {
                if (!this._planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = this._planes[key];
                this._scene.remove(plane);
                this._sceneOld.add(plane);
            }
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                this._scene.add(planes[key]);
            }
            this._planesOld = this._planes;
            this._planes = planes;
        }
        addImagePlanes(planes) {
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                this._scene.add(plane);
                this._planes[key] = plane;
            }
        }
        addImagePlanesOld(planes) {
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                this._sceneOld.add(plane);
                this._planesOld[key] = plane;
            }
        }
        setImagePlanes(planes) {
            this._clear();
            this.addImagePlanes(planes);
        }
        addPeripheryPlanes(planes) {
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                this._scenePeriphery.add(plane);
                this._planesPeriphery[key] = plane;
            }
        }
        setPeripheryPlanes(planes) {
            this._clearPeriphery();
            this.addPeripheryPlanes(planes);
        }
        setImagePlanesOld(planes) {
            this._clearOld();
            this.addImagePlanesOld(planes);
        }
        clear() {
            this._clear();
            this._clearOld();
        }
        _clear() {
            this._dispose(this._planes, this._scene);
            this._planes = {};
        }
        _clearOld() {
            this._dispose(this._planesOld, this._sceneOld);
            this._planesOld = {};
        }
        _clearPeriphery() {
            this._dispose(this._planesPeriphery, this._scenePeriphery);
            this._planesPeriphery = {};
        }
        _dispose(planes, scene) {
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                scene.remove(plane);
                plane.geometry.dispose();
                plane.material.dispose();
                let texture = plane.material.uniforms.projectorTex.value;
                if (texture != null) {
                    texture.dispose();
                }
            }
        }
    }

    class ImageGLRenderer {
        constructor() {
            this._factory = new MeshFactory();
            this._scene = new MeshScene();
            this._alpha = 0;
            this._alphaOld = 0;
            this._fadeOutSpeed = 0.05;
            this._currentKey = null;
            this._previousKey = null;
            this._providerDisposers = {};
            this._frameId = 0;
            this._needsRender = false;
        }
        get frameId() {
            return this._frameId;
        }
        get needsRender() {
            return this._needsRender;
        }
        indicateNeedsRender() {
            this._needsRender = true;
        }
        addPeripheryPlane(image, transform) {
            const mesh = this._factory.createMesh(image, transform);
            const planes = {};
            planes[image.id] = mesh;
            this._scene.addPeripheryPlanes(planes);
            this._needsRender = true;
        }
        clearPeripheryPlanes() {
            this._scene.setPeripheryPlanes({});
            this._needsRender = true;
        }
        updateFrame(frame) {
            this._updateFrameId(frame.id);
            this._needsRender = this._updateAlpha(frame.state.alpha) || this._needsRender;
            this._needsRender = this._updateAlphaOld(frame.state.alpha) || this._needsRender;
            this._needsRender = this._updateImagePlanes(frame.state) || this._needsRender;
        }
        setTextureProvider(key, provider) {
            if (key !== this._currentKey) {
                return;
            }
            let createdSubscription = provider.textureCreated$
                .subscribe((texture) => {
                this._updateTexture(texture);
            });
            let updatedSubscription = provider.textureUpdated$
                .subscribe((updated) => {
                this._needsRender = true;
            });
            let dispose = () => {
                createdSubscription.unsubscribe();
                updatedSubscription.unsubscribe();
                provider.dispose();
            };
            if (key in this._providerDisposers) {
                let disposeProvider = this._providerDisposers[key];
                disposeProvider();
                delete this._providerDisposers[key];
            }
            this._providerDisposers[key] = dispose;
        }
        updateTextureImage(imageElement, image) {
            this._needsRender = true;
            const planes = this._extend({}, this._scene.planes, this._scene.planesOld, this._scene.planesPeriphery);
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                if (key !== image.id) {
                    continue;
                }
                const plane = planes[key];
                let material = plane.material;
                let texture = material.uniforms.projectorTex.value;
                texture.image = imageElement;
                texture.needsUpdate = true;
            }
        }
        render(perspectiveCamera, renderer) {
            const planes = this._scene.planes;
            const planesOld = this._scene.planesOld;
            const planesPeriphery = this._scene.planesPeriphery;
            const planeAlpha = Object.keys(planesOld).length ? 1 : this._alpha;
            const peripheryAlpha = Object.keys(planesOld).length ? 1 : Math.floor(this._alpha);
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                plane.material.uniforms.opacity.value = planeAlpha;
            }
            for (const key in planesOld) {
                if (!planesOld.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planesOld[key];
                plane.material.uniforms.opacity.value = this._alphaOld;
            }
            for (const key in planesPeriphery) {
                if (!planesPeriphery.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planesPeriphery[key];
                plane.material.uniforms.opacity.value = peripheryAlpha;
            }
            renderer.render(this._scene.scenePeriphery, perspectiveCamera);
            renderer.render(this._scene.scene, perspectiveCamera);
            renderer.render(this._scene.sceneOld, perspectiveCamera);
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                plane.material.uniforms.opacity.value = this._alpha;
            }
            renderer.render(this._scene.scene, perspectiveCamera);
        }
        clearNeedsRender() {
            this._needsRender = false;
        }
        dispose() {
            this._scene.clear();
        }
        _updateFrameId(frameId) {
            this._frameId = frameId;
        }
        _updateAlpha(alpha) {
            if (alpha === this._alpha) {
                return false;
            }
            this._alpha = alpha;
            return true;
        }
        _updateAlphaOld(alpha) {
            if (alpha < 1 || this._alphaOld === 0) {
                return false;
            }
            this._alphaOld = Math.max(0, this._alphaOld - this._fadeOutSpeed);
            return true;
        }
        _updateImagePlanes(state) {
            if (state.currentImage == null ||
                state.currentImage.id === this._currentKey) {
                return false;
            }
            let previousKey = state.previousImage != null ? state.previousImage.id : null;
            let currentKey = state.currentImage.id;
            if (this._previousKey !== previousKey &&
                this._previousKey !== currentKey &&
                this._previousKey in this._providerDisposers) {
                let disposeProvider = this._providerDisposers[this._previousKey];
                disposeProvider();
                delete this._providerDisposers[this._previousKey];
            }
            if (previousKey != null) {
                if (previousKey !== this._currentKey && previousKey !== this._previousKey) {
                    let previousMesh = this._factory.createMesh(state.previousImage, state.previousTransform);
                    const previousPlanes = {};
                    previousPlanes[previousKey] = previousMesh;
                    this._scene.updateImagePlanes(previousPlanes);
                }
                this._previousKey = previousKey;
            }
            this._currentKey = currentKey;
            let currentMesh = this._factory.createMesh(state.currentImage, state.currentTransform);
            const planes = {};
            planes[currentKey] = currentMesh;
            this._scene.updateImagePlanes(planes);
            this._alphaOld = 1;
            return true;
        }
        _updateTexture(texture) {
            this._needsRender = true;
            const planes = this._scene.planes;
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                let material = plane.material;
                let oldTexture = material.uniforms.projectorTex.value;
                material.uniforms.projectorTex.value = null;
                oldTexture.dispose();
                material.uniforms.projectorTex.value = texture;
            }
        }
        _extend(dest, ...sources) {
            for (const src of sources) {
                for (const k in src) {
                    if (!src.hasOwnProperty(k)) {
                        continue;
                    }
                    dest[k] = src[k];
                }
            }
            return dest;
        }
    }

    var RenderPass;
    (function (RenderPass) {
        RenderPass[RenderPass["Background"] = 0] = "Background";
        RenderPass[RenderPass["Opaque"] = 1] = "Opaque";
    })(RenderPass || (RenderPass = {}));

    /**
     * @class ImageTileLoader
     *
     * @classdesc Represents a loader of image tiles.
     */
    class TileLoader {
        /**
         * Create a new image image tile loader instance.
         *
         * @param {APIWrapper} _api - API wrapper.
         */
        constructor(_api) {
            this._api = _api;
            this._urls$ = new Map();
        }
        /**
         * Retrieve an image tile.
         *
         * @param {string} url - URL to the image tile resource
         */
        getImage$(url) {
            let aborter;
            const abort = new Promise((_, reject) => {
                aborter = reject;
            });
            return [Observable.create((subscriber) => {
                    this._api.data
                        .getImageBuffer(url, abort)
                        .then((buffer) => {
                        aborter = null;
                        const image = new Image();
                        image.crossOrigin = "Anonymous";
                        image.onload = () => {
                            window.URL.revokeObjectURL(image.src);
                            subscriber.next(image);
                            subscriber.complete();
                        };
                        image.onerror = () => {
                            aborter = null;
                            window.URL.revokeObjectURL(image.src);
                            subscriber.error(new Error(`Failed to load image tile`));
                        };
                        const blob = new Blob([buffer]);
                        image.src = window.URL.createObjectURL(blob);
                    }, (error) => {
                        aborter = null;
                        subscriber.error(error);
                    });
                }),
                () => {
                    if (!!aborter) {
                        aborter();
                    }
                }];
        }
        getURLs$(imageId, level) {
            const uniqueId = this._inventId(imageId, level);
            if (this._urls$.has(uniqueId)) {
                return this._urls$.get(uniqueId);
            }
            const request = { imageId, z: level };
            const urls$ = this._api
                .getImageTiles$(request)
                .pipe(map(contract => contract.node), finalize(() => {
                this._urls$.delete(uniqueId);
            }), publish(), refCount());
            this._urls$.set(uniqueId, urls$);
            return urls$;
        }
        _inventId(imageId, level) {
            return `${imageId}-${level}`;
        }
    }

    /**
     * @class ImageTileStore
     *
     * @classdesc Represents a store for image tiles.
     */
    class TileStore {
        /**
         * Create a new image image tile store instance.
         */
        constructor() {
            this._tiles = new Map();
            this._urlLevels = new Set();
            this._urls = new Map();
        }
        /**
         * Add an image tile to the store.
         *
         * @param {string} id - The identifier for the image tile.
         * @param {HTMLImageElement} image - The image tile.
         */
        add(id, image) {
            if (this._tiles.has(id)) {
                throw new Error(`Image tile already stored (${id})`);
            }
            this._tiles.set(id, image);
        }
        addURLs(level, ents) {
            const urls = this._urls;
            for (const ent of ents) {
                const id = this.inventId(ent);
                if (this._urls.has(id)) {
                    throw new Error(`URL already stored (${id})`);
                }
                urls.set(id, ent.url);
            }
            this._urlLevels.add(level);
        }
        /**
         * Dispose the store.
         *
         * @description Disposes all cached assets.
         */
        dispose() {
            this._tiles
                .forEach(image => window.URL.revokeObjectURL(image.src));
            this._tiles.clear();
            this._urls.clear();
            this._urlLevels.clear();
        }
        /**
         * Get an image tile from the store.
         *
         * @param {string} id - The identifier for the tile.
         * @param {number} level - The level of the tile.
         */
        get(id) {
            return this._tiles.get(id);
        }
        getURL(id) {
            return this._urls.get(id);
        }
        /**
         * Check if an image tile exist in the store.
         *
         * @param {string} id - The identifier for the tile.
         * @param {number} level - The level of the tile.
         */
        has(id) {
            return this._tiles.has(id);
        }
        hasURL(id) {
            return this._urls.has(id);
        }
        hasURLLevel(level) {
            return this._urlLevels.has(level);
        }
        /**
         * Create a unique tile id from a tile.
         *
         * @description Tile ids are used as a hash for
         * storing the tile in a dictionary.
         *
         * @param {ImageTileEnt} tile - The tile.
         * @returns {string} Unique id.
         */
        inventId(tile) {
            return `${tile.z}-${tile.x}-${tile.y}`;
        }
    }

    /**
     * @class RegionOfInterestCalculator
     *
     * @classdesc Represents a calculator for regions of interest.
     */
    class RegionOfInterestCalculator {
        constructor() {
            this._viewportCoords = new ViewportCoords();
        }
        /**
         * Compute a region of interest based on the current render camera
         * and the viewport size.
         *
         * @param {RenderCamera} renderCamera - Render camera used for unprojections.
         * @param {ViewportSize} size - Viewport size in pixels.
         * @param {Transform} transform - Transform used for projections.
         *
         * @returns {TileRegionOfInterest} A region of interest.
         */
        computeRegionOfInterest(renderCamera, size, transform) {
            const viewportBoundaryPoints = this._viewportBoundaryPoints(4);
            const bbox = this._viewportPointsBoundingBox(viewportBoundaryPoints, renderCamera, transform);
            this._clipBoundingBox(bbox);
            const viewportPixelWidth = 2 / size.width;
            const viewportPixelHeight = 2 / size.height;
            const centralViewportPixel = [
                [-0.5 * viewportPixelWidth, 0.5 * viewportPixelHeight],
                [0.5 * viewportPixelWidth, 0.5 * viewportPixelHeight],
                [0.5 * viewportPixelWidth, -0.5 * viewportPixelHeight],
                [-0.5 * viewportPixelWidth, -0.5 * viewportPixelHeight],
            ];
            const cpbox = this._viewportPointsBoundingBox(centralViewportPixel, renderCamera, transform);
            const inverted = cpbox.minX < cpbox.maxX;
            return {
                bbox: bbox,
                pixelHeight: cpbox.maxY - cpbox.minY,
                pixelWidth: cpbox.maxX - cpbox.minX + (inverted ? 0 : 1),
            };
        }
        _viewportBoundaryPoints(pointsPerSide) {
            const points = [];
            const os = [[-1, 1], [1, 1], [1, -1], [-1, -1]];
            const ds = [[2, 0], [0, -2], [-2, 0], [0, 2]];
            for (let side = 0; side < 4; ++side) {
                const o = os[side];
                const d = ds[side];
                for (let i = 0; i < pointsPerSide; ++i) {
                    points.push([o[0] + d[0] * i / pointsPerSide,
                        o[1] + d[1] * i / pointsPerSide]);
                }
            }
            return points;
        }
        _viewportPointsBoundingBox(viewportPoints, renderCamera, transform) {
            const basicPoints = viewportPoints
                .map((point) => {
                return this._viewportCoords
                    .viewportToBasic(point[0], point[1], transform, renderCamera.perspective);
            });
            if (isSpherical(transform.cameraType)) {
                return this._boundingBoxSpherical(basicPoints);
            }
            else {
                return this._boundingBox(basicPoints);
            }
        }
        _boundingBox(points) {
            const bbox = {
                maxX: Number.NEGATIVE_INFINITY,
                maxY: Number.NEGATIVE_INFINITY,
                minX: Number.POSITIVE_INFINITY,
                minY: Number.POSITIVE_INFINITY,
            };
            for (let i = 0; i < points.length; ++i) {
                bbox.minX = Math.min(bbox.minX, points[i][0]);
                bbox.maxX = Math.max(bbox.maxX, points[i][0]);
                bbox.minY = Math.min(bbox.minY, points[i][1]);
                bbox.maxY = Math.max(bbox.maxY, points[i][1]);
            }
            return bbox;
        }
        _boundingBoxSpherical(points) {
            const xs = [];
            const ys = [];
            for (let i = 0; i < points.length; ++i) {
                xs.push(points[i][0]);
                ys.push(points[i][1]);
            }
            xs.sort((a, b) => { return this._sign(a - b); });
            ys.sort((a, b) => { return this._sign(a - b); });
            const intervalX = this._intervalSpherical(xs);
            return {
                maxX: intervalX[1],
                maxY: ys[ys.length - 1],
                minX: intervalX[0],
                minY: ys[0],
            };
        }
        /**
         * Find the max interval between consecutive numbers.
         * Assumes numbers are between 0 and 1, sorted and that
         * x is equivalent to x + 1.
         */
        _intervalSpherical(xs) {
            let maxdx = 0;
            let maxi = -1;
            for (let i = 0; i < xs.length - 1; ++i) {
                const dx = xs[i + 1] - xs[i];
                if (dx > maxdx) {
                    maxdx = dx;
                    maxi = i;
                }
            }
            const loopdx = xs[0] + 1 - xs[xs.length - 1];
            if (loopdx > maxdx) {
                return [xs[0], xs[xs.length - 1]];
            }
            else {
                return [xs[maxi + 1], xs[maxi]];
            }
        }
        _clipBoundingBox(bbox) {
            bbox.minX = Math.max(0, Math.min(1, bbox.minX));
            bbox.maxX = Math.max(0, Math.min(1, bbox.maxX));
            bbox.minY = Math.max(0, Math.min(1, bbox.minY));
            bbox.maxY = Math.max(0, Math.min(1, bbox.maxY));
        }
        _sign(n) {
            return n > 0 ? 1 : n < 0 ? -1 : 0;
        }
    }

    const TILE_MIN_REQUEST_LEVEL = 11;
    const TILE_SIZE = 1024;

    function clamp(value, min, max) {
        return Math.max(min, Math.min(max, value));
    }
    function levelTilePixelSize(level) {
        return TILE_SIZE / levelScale(level);
    }
    function levelScale(level) {
        return Math.pow(2, level.z - level.max);
    }
    function rawImageLevel(size) {
        const s = Math.max(size.w, size.h);
        return Math.log(s) / Math.log(2);
    }
    function baseImageLevel(size) {
        return Math.ceil(rawImageLevel(size));
    }
    function clampedImageLevel(size, min, max) {
        return Math.max(min, Math.min(max, baseImageLevel(size)));
    }
    function basicToTileCoords2D(basic, size, level) {
        const tilePixelSize = levelTilePixelSize(level);
        const w = size.w;
        const h = size.h;
        const maxX = Math.ceil(w / tilePixelSize) - 1;
        const maxY = Math.ceil(h / tilePixelSize) - 1;
        const x = clamp(Math.floor(w * basic[0] / tilePixelSize), 0, maxX);
        const y = clamp(Math.floor(h * basic[1] / tilePixelSize), 0, maxY);
        return { x, y };
    }
    function tileToPixelCoords2D(tile, size, level) {
        const scale = 1 / levelScale(level);
        const scaledTS = scale * TILE_SIZE;
        const x = scaledTS * tile.x;
        const y = scaledTS * tile.y;
        const w = Math.min(scaledTS, size.w - x);
        const h = Math.min(scaledTS, size.h - y);
        return { h, x, y, w };
    }
    function hasOverlap1D(low, base, scale) {
        return (scale * low <= base &&
            base < scale * (low + 1));
    }
    function hasOverlap2D(tile1, tile2) {
        if (tile1.z === tile2.z) {
            return tile1.x === tile2.x && tile1.y === tile2.y;
        }
        const low = tile1.z < tile2.z ? tile1 : tile2;
        const base = tile1.z < tile2.z ? tile2 : tile1;
        const scale = 1 / levelScale({ max: base.z, z: low.z });
        const overlapX = hasOverlap1D(low.x, base.x, scale);
        const overlapY = hasOverlap1D(low.y, base.y, scale);
        return overlapX && overlapY;
    }
    function cornersToTilesCoords2D(topLeft, bottomRight, size, level) {
        const xs = [];
        if (topLeft.x > bottomRight.x) {
            const tilePixelSize = levelTilePixelSize(level);
            const maxX = Math.ceil(size.w / tilePixelSize) - 1;
            for (let x = topLeft.x; x <= maxX; x++) {
                xs.push(x);
            }
            for (let x = 0; x <= bottomRight.x; x++) {
                xs.push(x);
            }
        }
        else {
            for (let x = topLeft.x; x <= bottomRight.x; x++) {
                xs.push(x);
            }
        }
        const tiles = [];
        for (const x of xs) {
            for (let y = topLeft.y; y <= bottomRight.y; y++) {
                tiles.push({ x, y });
            }
        }
        return tiles;
    }
    function verifySize(size) {
        return size.w > 0 && size.h > 0;
    }

    /**
     * @class TextureProvider
     *
     * @classdesc Represents a provider of textures.
     */
    class TextureProvider {
        /**
         * Create a new image texture provider instance.
         *
         * @param {string} imageId - The identifier of the image for which to request tiles.
         * @param {number} width - The full width of the original image.
         * @param {number} height - The full height of the original image.
         * @param {HTMLImageElement} background - Image to use as background.
         * @param {TileLoader} loader - Loader for retrieving tiles.
         * @param {TileStore} store - Store for saving tiles.
         * @param {THREE.WebGLRenderer} renderer - Renderer used for rendering tiles to texture.
         */
        constructor(imageId, width, height, background, loader, store, renderer) {
            const size = { h: height, w: width };
            if (!verifySize(size)) {
                console.warn(`Original image size (${width}, ${height}) ` +
                    `is invalid (${imageId}). Tiles will not be loaded.`);
            }
            this._imageId = imageId;
            this._size = size;
            this._level = {
                max: baseImageLevel(this._size),
                z: -1,
            };
            this._holder = new SubscriptionHolder();
            this._updated$ = new Subject();
            this._createdSubject$ = new Subject();
            this._created$ = this._createdSubject$
                .pipe(publishReplay(1), refCount());
            this._holder.push(this._created$.subscribe(() => { }));
            this._hasSubject$ = new Subject();
            this._has$ = this._hasSubject$
                .pipe(startWith(false), publishReplay(1), refCount());
            this._holder.push(this._has$.subscribe(() => { }));
            this._renderedLevel = new Set();
            this._rendered = new Map();
            this._subscriptions = new Map();
            this._urlSubscriptions = new Map();
            this._loader = loader;
            this._store = store;
            this._background = background;
            this._renderer = renderer;
            this._aborts = [];
            this._render = null;
            this._disposed = false;
        }
        /**
         * Get disposed.
         *
         * @returns {boolean} Value indicating whether provider has
         * been disposed.
         */
        get disposed() {
            return this._disposed;
        }
        /**
         * Get hasTexture$.
         *
         * @returns {Observable<boolean>} Observable emitting
         * values indicating when the existance of a texture
         * changes.
         */
        get hasTexture$() {
            return this._has$;
        }
        /**
         * Get id.
         *
         * @returns {boolean} The identifier of the image for
         * which to render textures.
         */
        get id() {
            return this._imageId;
        }
        /**
         * Get textureUpdated$.
         *
         * @returns {Observable<boolean>} Observable emitting
         * values when an existing texture has been updated.
         */
        get textureUpdated$() {
            return this._updated$;
        }
        /**
         * Get textureCreated$.
         *
         * @returns {Observable<boolean>} Observable emitting
         * values when a new texture has been created.
         */
        get textureCreated$() {
            return this._created$;
        }
        /**
         * Abort all outstanding image tile requests.
         */
        abort() {
            this._subscriptions.forEach(sub => sub.unsubscribe());
            this._subscriptions.clear();
            for (const abort of this._aborts) {
                abort();
            }
            this._aborts = [];
        }
        /**
         * Dispose the provider.
         *
         * @description Disposes all cached assets and
         * aborts all outstanding image tile requests.
         */
        dispose() {
            if (this._disposed) {
                console.warn(`Texture already disposed (${this._imageId})`);
                return;
            }
            this._urlSubscriptions.forEach(sub => sub.unsubscribe());
            this._urlSubscriptions.clear();
            this.abort();
            if (this._render != null) {
                this._render.target.dispose();
                this._render.target = null;
                this._render.camera = null;
                this._render = null;
            }
            this._store.dispose();
            this._holder.unsubscribe();
            this._renderedLevel.clear();
            this._background = null;
            this._renderer = null;
            this._disposed = true;
        }
        /**
         * Set the region of interest.
         *
         * @description When the region of interest is set the
         * the tile level is determined and tiles for the region
         * are fetched from the store or the loader and renderedLevel
         * to the texture.
         *
         * @param {TileRegionOfInterest} roi - Spatial edges to cache.
         */
        setRegionOfInterest(roi) {
            if (!verifySize(this._size)) {
                return;
            }
            const virtualWidth = 1 / roi.pixelWidth;
            const virtualHeight = 1 / roi.pixelHeight;
            const level = clampedImageLevel({ h: virtualHeight, w: virtualWidth }, TILE_MIN_REQUEST_LEVEL, this._level.max);
            if (level !== this._level.z) {
                this.abort();
                this._level.z = level;
                this._renderedLevel.clear();
                this._rendered
                    .forEach((tile, id) => {
                    if (tile.z !== level) {
                        return;
                    }
                    this._renderedLevel.add(id);
                });
            }
            if (this._render == null) {
                this._initRender();
            }
            const topLeft = basicToTileCoords2D([roi.bbox.minX, roi.bbox.minY], this._size, this._level);
            const bottomRight = basicToTileCoords2D([roi.bbox.maxX, roi.bbox.maxY], this._size, this._level);
            const tiles = cornersToTilesCoords2D(topLeft, bottomRight, this._size, this._level);
            this._fetchTiles(level, tiles);
        }
        /**
         * Retrieve an image tile.
         *
         * @description Retrieve an image tile and render it to the
         * texture. Add the tile to the store and emit to the updated
         * observable.
         *
         * @param {ImageTileEnt} tile - The tile ent.
         */
        _fetchTile(tile) {
            const getTile = this._loader.getImage$(tile.url);
            const tile$ = getTile[0];
            const abort = getTile[1];
            this._aborts.push(abort);
            const tileId = this._store.inventId(tile);
            const subscription = tile$.subscribe((image) => {
                const pixels = tileToPixelCoords2D(tile, this._size, this._level);
                this._renderToTarget(pixels, image);
                this._subscriptions.delete(tileId);
                this._removeFromArray(abort, this._aborts);
                this._markRendered(tile);
                this._store.add(tileId, image);
                this._updated$.next(true);
            }, (error) => {
                this._subscriptions.delete(tileId);
                this._removeFromArray(abort, this._aborts);
                console.error(error);
            });
            if (!subscription.closed) {
                this._subscriptions.set(tileId, subscription);
            }
        }
        /**
         * Fetch image tiles.
         *
         * @description Retrieve a image tiles and render them to the
         * texture. Retrieve from store if it exists, otherwise retrieve
         * from loader.
         *
         * @param {Array<TileCoords2D>} tiles - Array of tile coordinates to
         * retrieve.
         */
        _fetchTiles(level, tiles) {
            const urls$ = this._store.hasURLLevel(level) ?
                of(undefined) :
                this._loader
                    .getURLs$(this._imageId, level)
                    .pipe(tap(ents => {
                    if (!this._store.hasURLLevel(level)) {
                        this._store.addURLs(level, ents);
                    }
                }));
            const subscription = urls$.subscribe(() => {
                if (level !== this._level.z) {
                    return;
                }
                for (const tile of tiles) {
                    const ent = {
                        x: tile.x,
                        y: tile.y,
                        z: level,
                        url: null,
                    };
                    const id = this._store.inventId(ent);
                    if (this._renderedLevel.has(id) ||
                        this._subscriptions.has(id)) {
                        continue;
                    }
                    if (this._store.has(id)) {
                        const pixels = tileToPixelCoords2D(tile, this._size, this._level);
                        this._renderToTarget(pixels, this._store.get(id));
                        this._markRendered(ent);
                        this._updated$.next(true);
                        continue;
                    }
                    ent.url = this._store.getURL(id);
                    this._fetchTile(ent);
                }
                this._urlSubscriptions.delete(level);
            }, (error) => {
                this._urlSubscriptions.delete(level);
                console.error(error);
            });
            if (!subscription.closed) {
                this._urlSubscriptions.set(level, subscription);
            }
        }
        _initRender() {
            const dx = this._size.w / 2;
            const dy = this._size.h / 2;
            const near = -1;
            const far = 1;
            const camera = new OrthographicCamera(-dx, dx, dy, -dy, near, far);
            camera.position.z = 1;
            const gl = this._renderer.getContext();
            const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
            const backgroundSize = Math.max(this._size.w, this._size.h);
            const scale = maxTextureSize > backgroundSize ?
                1 : maxTextureSize / backgroundSize;
            const targetWidth = Math.floor(scale * this._size.w);
            const targetHeight = Math.floor(scale * this._size.h);
            const target = new WebGLRenderTarget(targetWidth, targetHeight, {
                depthBuffer: false,
                format: RGBFormat,
                magFilter: LinearFilter,
                minFilter: LinearFilter,
                stencilBuffer: false,
            });
            this._render = { camera, target };
            const pixels = tileToPixelCoords2D({ x: 0, y: 0 }, this._size, { max: this._level.max, z: 0 });
            this._renderToTarget(pixels, this._background);
            this._createdSubject$.next(target.texture);
            this._hasSubject$.next(true);
        }
        /**
         * Mark a tile as rendered.
         *
         * @description Clears tiles marked as rendered in other
         * levels of the tile pyramid if they overlap the
         * newly rendered tile.
         *
         * @param {Arrary<number>} tile - The tile ent.
         */
        _markRendered(tile) {
            const others = Array.from(this._rendered.entries())
                .filter(([_, t]) => {
                return t.z !== tile.z;
            });
            for (const [otherId, other] of others) {
                if (hasOverlap2D(tile, other)) {
                    this._rendered.delete(otherId);
                }
            }
            const id = this._store.inventId(tile);
            this._rendered.set(id, tile);
            this._renderedLevel.add(id);
        }
        /**
         * Remove an item from an array if it exists in array.
         *
         * @param {T} item - Item to remove.
         * @param {Array<T>} array - Array from which item should be removed.
         */
        _removeFromArray(item, array) {
            const index = array.indexOf(item);
            if (index !== -1) {
                array.splice(index, 1);
            }
        }
        /**
         * Render an image tile to the target texture.
         *
         * @param {ImageTileEnt} tile - Tile ent.
         * @param {HTMLImageElement} image - The image tile to render.
         */
        _renderToTarget(pixel, image) {
            const texture = new Texture(image);
            texture.minFilter = LinearFilter;
            texture.needsUpdate = true;
            const geometry = new PlaneGeometry(pixel.w, pixel.h);
            const material = new MeshBasicMaterial({
                map: texture,
                side: FrontSide,
            });
            const mesh = new Mesh(geometry, material);
            mesh.position.x = -this._size.w / 2 + pixel.x + pixel.w / 2;
            mesh.position.y = this._size.h / 2 - pixel.y - pixel.h / 2;
            const scene = new Scene();
            scene.add(mesh);
            const target = this._renderer.getRenderTarget();
            this._renderer.resetState();
            this._renderer.setRenderTarget(this._render.target);
            this._renderer.render(scene, this._render.camera);
            this._renderer.setRenderTarget(target);
            scene.remove(mesh);
            geometry.dispose();
            material.dispose();
            texture.dispose();
        }
    }

    var State;
    (function (State) {
        State[State["Custom"] = 0] = "Custom";
        State[State["Earth"] = 1] = "Earth";
        State[State["Traversing"] = 2] = "Traversing";
        State[State["Waiting"] = 3] = "Waiting";
        State[State["WaitingInteractively"] = 4] = "WaitingInteractively";
    })(State || (State = {}));

    class ImageComponent extends Component {
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._imageTileLoader = new TileLoader(navigator.api);
            this._roiCalculator = new RegionOfInterestCalculator();
            this._rendererOperation$ = new Subject();
            this._rendererCreator$ = new Subject();
            this._rendererDisposer$ = new Subject();
            this._renderer$ = this._rendererOperation$.pipe(scan((renderer, operation) => {
                return operation(renderer);
            }, null), filter((renderer) => {
                return renderer != null;
            }), distinctUntilChanged(undefined, (renderer) => {
                return renderer.frameId;
            }));
            this._rendererCreator$.pipe(map(() => {
                return (renderer) => {
                    if (renderer != null) {
                        throw new Error("Multiple image plane states can not be created at the same time");
                    }
                    return new ImageGLRenderer();
                };
            }))
                .subscribe(this._rendererOperation$);
            this._rendererDisposer$.pipe(map(() => {
                return (renderer) => {
                    renderer.dispose();
                    return null;
                };
            }))
                .subscribe(this._rendererOperation$);
        }
        _activate() {
            const subs = this._subscriptions;
            subs.push(this._renderer$.pipe(map((renderer) => {
                const renderHash = {
                    name: this._name,
                    renderer: {
                        frameId: renderer.frameId,
                        needsRender: renderer.needsRender,
                        render: renderer.render.bind(renderer),
                        pass: RenderPass.Background,
                    },
                };
                renderer.clearNeedsRender();
                return renderHash;
            }))
                .subscribe(this._container.glRenderer.render$));
            this._rendererCreator$.next(null);
            subs.push(this._navigator.stateService.currentState$.pipe(map((frame) => {
                return (renderer) => {
                    renderer.updateFrame(frame);
                    return renderer;
                };
            }))
                .subscribe(this._rendererOperation$));
            const textureProvider$ = this._container.configurationService.imageTiling$.pipe(switchMap((active) => {
                return active ?
                    this._navigator.stateService.currentState$ :
                    new Subject();
            }), distinctUntilChanged(undefined, (frame) => {
                return frame.state.currentImage.id;
            }), withLatestFrom(this._container.glRenderer.webGLRenderer$), map(([frame, renderer]) => {
                const state = frame.state;
                const currentNode = state.currentImage;
                const currentTransform = state.currentTransform;
                return new TextureProvider(currentNode.id, currentTransform.basicWidth, currentTransform.basicHeight, currentNode.image, this._imageTileLoader, new TileStore(), renderer);
            }), publishReplay(1), refCount());
            subs.push(textureProvider$.subscribe(() => { }));
            subs.push(textureProvider$.pipe(map((provider) => {
                return (renderer) => {
                    renderer.setTextureProvider(provider.id, provider);
                    return renderer;
                };
            }))
                .subscribe(this._rendererOperation$));
            subs.push(textureProvider$.pipe(pairwise())
                .subscribe((pair) => {
                const previous = pair[0];
                previous.abort();
            }));
            const roiTrigger$ = this._container.configurationService.imageTiling$.pipe(switchMap((active) => {
                return active ?
                    combineLatest(this._navigator.stateService.state$, this._navigator.stateService.inTranslation$) :
                    new Subject();
            }), switchMap(([state, inTranslation]) => {
                const streetState = state === State.Traversing ||
                    state === State.Waiting ||
                    state === State.WaitingInteractively;
                const active = streetState && !inTranslation;
                return active ?
                    this._container.renderService.renderCameraFrame$ :
                    empty();
            }), map((camera) => {
                return {
                    camera,
                    height: camera.size.height.valueOf(),
                    lookat: camera.camera.lookat.clone(),
                    width: camera.size.width.valueOf(),
                    zoom: camera.zoom.valueOf(),
                };
            }), pairwise(), map(([pl0, pl1]) => {
                const stalled = pl0.width === pl1.width &&
                    pl0.height === pl1.height &&
                    pl0.zoom === pl1.zoom &&
                    pl0.lookat.equals(pl1.lookat);
                return { camera: pl1.camera, stalled };
            }), distinctUntilChanged((x, y) => {
                return x.stalled === y.stalled;
            }), filter((camera) => {
                return camera.stalled;
            }), withLatestFrom(this._container.renderService.size$, this._navigator.stateService.currentTransform$));
            subs.push(textureProvider$.pipe(switchMap((provider) => {
                return roiTrigger$.pipe(map(([stalled, size, transform]) => {
                    const camera = stalled.camera;
                    const basic = new ViewportCoords()
                        .viewportToBasic(0, 0, transform, camera.perspective);
                    if (basic[0] < 0 ||
                        basic[1] < 0 ||
                        basic[0] > 1 ||
                        basic[1] > 1) {
                        return undefined;
                    }
                    return [
                        this._roiCalculator
                            .computeRegionOfInterest(camera, size, transform),
                        provider,
                    ];
                }), filter((args) => {
                    return !!args;
                }));
            }), filter((args) => {
                return !args[1].disposed;
            }))
                .subscribe(([roi, provider]) => {
                provider.setRegionOfInterest(roi);
            }));
            const hasTexture$ = textureProvider$
                .pipe(switchMap((provider) => {
                return provider.hasTexture$;
            }), startWith(false), publishReplay(1), refCount());
            subs.push(hasTexture$.subscribe(() => { }));
            subs.push(this._navigator.panService.panImages$.pipe(filter((panNodes) => {
                return panNodes.length === 0;
            }), map(() => {
                return (renderer) => {
                    renderer.clearPeripheryPlanes();
                    return renderer;
                };
            }))
                .subscribe(this._rendererOperation$));
            const cachedPanNodes$ = this._navigator.panService.panImages$.pipe(switchMap((nts) => {
                return from(nts).pipe(mergeMap(([n, t]) => {
                    return combineLatest(this._navigator.graphService.cacheImage$(n.id).pipe(catchError((error) => {
                        console.error(`Failed to cache periphery image (${n.id})`, error);
                        return empty();
                    })), of(t));
                }));
            }), share());
            subs.push(cachedPanNodes$.pipe(map(([n, t]) => {
                return (renderer) => {
                    renderer.addPeripheryPlane(n, t);
                    return renderer;
                };
            }))
                .subscribe(this._rendererOperation$));
            subs.push(cachedPanNodes$.pipe(mergeMap(([n]) => {
                return n.cacheImage$().pipe(catchError(() => {
                    return empty();
                }));
            }), map((n) => {
                return (renderer) => {
                    renderer.updateTextureImage(n.image, n);
                    return renderer;
                };
            }))
                .subscribe(this._rendererOperation$));
            const inTransition$ = this._navigator.stateService.currentState$.pipe(map((frame) => {
                return frame.state.alpha < 1;
            }), distinctUntilChanged());
            const panTrigger$ = combineLatest(this._container.mouseService.active$, this._container.touchService.active$, this._navigator.stateService.inMotion$, inTransition$).pipe(map(([mouseActive, touchActive, inMotion, inTransition]) => {
                return !(mouseActive || touchActive || inMotion || inTransition);
            }), filter((trigger) => {
                return trigger;
            }));
            subs.push(this._navigator.stateService.state$
                .pipe(switchMap(state => {
                return state === State.Traversing ?
                    this._navigator.panService.panImages$ :
                    empty();
            }), switchMap((nts) => {
                return panTrigger$.pipe(withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentImage$, this._navigator.stateService.currentTransform$), mergeMap(([, renderCamera, currentNode, currentTransform]) => {
                    return of([
                        renderCamera,
                        currentNode,
                        currentTransform,
                        nts,
                    ]);
                }));
            }), switchMap(([camera, cn, ct, nts]) => {
                const direction = camera.camera.lookat.clone().sub(camera.camera.position);
                const cd = new Spatial().viewingDirection(cn.rotation);
                const ca = cd.angleTo(direction);
                const closest = [ca, undefined];
                const basic = new ViewportCoords().viewportToBasic(0, 0, ct, camera.perspective);
                if (basic[0] >= 0 && basic[0] <= 1 && basic[1] >= 0 && basic[1] <= 1) {
                    closest[0] = Number.NEGATIVE_INFINITY;
                }
                for (const [n] of nts) {
                    const d = new Spatial().viewingDirection(n.rotation);
                    const a = d.angleTo(direction);
                    if (a < closest[0]) {
                        closest[0] = a;
                        closest[1] = n.id;
                    }
                }
                if (!closest[1]) {
                    return empty();
                }
                return this._navigator.moveTo$(closest[1]).pipe(catchError(() => {
                    return empty();
                }));
            }))
                .subscribe());
        }
        _deactivate() {
            this._rendererDisposer$.next(null);
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return {};
        }
    }
    ImageComponent.componentName = "image";

    class HandlerBase {
        /** @ignore */
        constructor(component, container, navigator) {
            this._component = component;
            this._container = container;
            this._navigator = navigator;
            this._enabled = false;
        }
        /**
         * Returns a Boolean indicating whether the interaction is enabled.
         *
         * @returns {boolean} `true` if the interaction is enabled.
         */
        get isEnabled() {
            return this._enabled;
        }
        /**
         * Enables the interaction.
         *
         * @example
         * ```js
         * <component-name>.<handler-name>.enable();
         * ```
         */
        enable() {
            if (this._enabled || !this._component.activated) {
                return;
            }
            this._enable();
            this._enabled = true;
            this._component.configure(this._getConfiguration(true));
        }
        /**
         * Disables the interaction.
         *
         * @example
         * ```js
         * <component-name>.<handler-name>.disable();
         * ```
         */
        disable() {
            if (!this._enabled) {
                return;
            }
            this._disable();
            this._enabled = false;
            if (this._component.activated) {
                this._component.configure(this._getConfiguration(false));
            }
        }
    }

    /**
     * The `KeySequenceNavigationHandler` allows the user to navigate through a sequence using the
     * following key commands:
     *
     * `ALT` + `Up Arrow`: Navigate to next image in the sequence.
     * `ALT` + `Down Arrow`: Navigate to previous image in sequence.
     *
     * @example
     * ```js
     * var keyboardComponent = viewer.getComponent("keyboard");
     *
     * keyboardComponent.keySequenceNavigation.disable();
     * keyboardComponent.keySequenceNavigation.enable();
     *
     * var isEnabled = keyboardComponent.keySequenceNavigation.isEnabled;
     * ```
     */
    class KeySequenceNavigationHandler extends HandlerBase {
        _enable() {
            const sequenceEdges$ = this._navigator.stateService.currentImage$.pipe(switchMap((image) => {
                return image.sequenceEdges$;
            }));
            this._keyDownSubscription = this._container.keyboardService.keyDown$.pipe(withLatestFrom(sequenceEdges$))
                .subscribe(([event, edgeStatus]) => {
                let direction = null;
                switch (event.keyCode) {
                    case 38: // up
                        direction = exports.NavigationDirection.Next;
                        break;
                    case 40: // down
                        direction = exports.NavigationDirection.Prev;
                        break;
                    default:
                        return;
                }
                event.preventDefault();
                if (!event.altKey || event.shiftKey || !edgeStatus.cached) {
                    return;
                }
                for (const edge of edgeStatus.edges) {
                    if (edge.data.direction === direction) {
                        this._navigator.moveTo$(edge.target)
                            .subscribe(undefined, (error) => {
                            if (!(error instanceof CancelMapillaryError)) {
                                console.error(error);
                            }
                        });
                        return;
                    }
                }
            });
        }
        _disable() {
            this._keyDownSubscription.unsubscribe();
        }
        _getConfiguration(enable) {
            return { keySequenceNavigation: enable };
        }
    }

    /**
     * The `KeySpatialNavigationHandler` allows the user to navigate through a sequence using the
     * following key commands:
     *
     * `Up Arrow`: Step forward.
     * `Down Arrow`: Step backward.
     * `Left Arrow`: Step to the left.
     * `Rigth Arrow`: Step to the right.
     * `SHIFT` + `Down Arrow`: Turn around.
     * `SHIFT` + `Left Arrow`: Turn to the left.
     * `SHIFT` + `Rigth Arrow`: Turn to the right.
     *
     * @example
     * ```js
     * var keyboardComponent = viewer.getComponent("keyboard");
     *
     * keyboardComponent.keySpatialNavigation.disable();
     * keyboardComponent.keySpatialNavigation.enable();
     *
     * var isEnabled = keyboardComponent.keySpatialNavigation.isEnabled;
     * ```
     */
    class KeySpatialNavigationHandler extends HandlerBase {
        /** @ignore */
        constructor(component, container, navigator, spatial) {
            super(component, container, navigator);
            this._spatial = spatial;
        }
        _enable() {
            const spatialEdges$ = this._navigator.stateService.currentImage$.pipe(switchMap((image) => {
                return image.spatialEdges$;
            }));
            this._keyDownSubscription = this._container.keyboardService.keyDown$.pipe(withLatestFrom(spatialEdges$, this._navigator.stateService.currentState$))
                .subscribe(([event, edgeStatus, frame]) => {
                let spherical = isSpherical(frame.state.currentImage.cameraType);
                let direction = null;
                switch (event.keyCode) {
                    case 37: // left
                        direction = event.shiftKey && !spherical ? exports.NavigationDirection.TurnLeft : exports.NavigationDirection.StepLeft;
                        break;
                    case 38: // up
                        direction = event.shiftKey && !spherical ? exports.NavigationDirection.Spherical : exports.NavigationDirection.StepForward;
                        break;
                    case 39: // right
                        direction = event.shiftKey && !spherical ? exports.NavigationDirection.TurnRight : exports.NavigationDirection.StepRight;
                        break;
                    case 40: // down
                        direction = event.shiftKey && !spherical ? exports.NavigationDirection.TurnU : exports.NavigationDirection.StepBackward;
                        break;
                    default:
                        return;
                }
                event.preventDefault();
                if (event.altKey || !edgeStatus.cached ||
                    (event.shiftKey && spherical)) {
                    return;
                }
                if (!spherical) {
                    this._moveDir(direction, edgeStatus);
                }
                else {
                    const shifts = {};
                    shifts[exports.NavigationDirection.StepBackward] = Math.PI;
                    shifts[exports.NavigationDirection.StepForward] = 0;
                    shifts[exports.NavigationDirection.StepLeft] = Math.PI / 2;
                    shifts[exports.NavigationDirection.StepRight] = -Math.PI / 2;
                    const phi = this._rotationFromCamera(frame.state.camera).phi;
                    const navigationAngle = this._spatial.wrapAngle(phi + shifts[direction]);
                    const threshold = Math.PI / 4;
                    const edges = edgeStatus.edges.filter((e) => {
                        return e.data.direction === exports.NavigationDirection.Spherical || e.data.direction === direction;
                    });
                    let smallestAngle = Number.MAX_VALUE;
                    let toKey = null;
                    for (const edge of edges) {
                        const angle = Math.abs(this._spatial.wrapAngle(edge.data.worldMotionAzimuth - navigationAngle));
                        if (angle < Math.min(smallestAngle, threshold)) {
                            smallestAngle = angle;
                            toKey = edge.target;
                        }
                    }
                    if (toKey == null) {
                        return;
                    }
                    this._moveTo(toKey);
                }
            });
        }
        _disable() {
            this._keyDownSubscription.unsubscribe();
        }
        _getConfiguration(enable) {
            return { keySpatialNavigation: enable };
        }
        _moveDir(direction, edgeStatus) {
            for (const edge of edgeStatus.edges) {
                if (edge.data.direction === direction) {
                    this._moveTo(edge.target);
                    return;
                }
            }
        }
        _moveTo(id) {
            this._navigator.moveTo$(id)
                .subscribe(undefined, (error) => {
                if (!(error instanceof CancelMapillaryError)) {
                    console.error(error);
                }
            });
        }
        _rotationFromCamera(camera) {
            let direction = camera.lookat.clone().sub(camera.position);
            let upProjection = direction.clone().dot(camera.up);
            let planeProjection = direction.clone().sub(camera.up.clone().multiplyScalar(upProjection));
            let phi = Math.atan2(planeProjection.y, planeProjection.x);
            let theta = Math.PI / 2 - this._spatial.angleToPlane(direction.toArray(), [0, 0, 1]);
            return { phi: phi, theta: theta };
        }
    }

    /**
     * The `KeyZoomHandler` allows the user to zoom in and out using the
     * following key commands:
     *
     * `+`: Zoom in.
     * `-`: Zoom out.
     *
     * @example
     * ```js
     * var keyboardComponent = viewer.getComponent("keyboard");
     *
     * keyboardComponent.keyZoom.disable();
     * keyboardComponent.keyZoom.enable();
     *
     * var isEnabled = keyboardComponent.keyZoom.isEnabled;
     * ```
     */
    class KeyZoomHandler extends HandlerBase {
        /** @ignore */
        constructor(component, container, navigator, viewportCoords) {
            super(component, container, navigator);
            this._viewportCoords = viewportCoords;
        }
        _enable() {
            this._keyDownSubscription = this._container.keyboardService.keyDown$.pipe(withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$))
                .subscribe(([event, render, transform]) => {
                if (event.altKey || event.ctrlKey || event.metaKey) {
                    return;
                }
                let delta = 0;
                switch (event.key) {
                    case "+":
                        delta = 1;
                        break;
                    case "-":
                        delta = -1;
                        break;
                    default:
                        return;
                }
                event.preventDefault();
                const unprojected = this._viewportCoords.unprojectFromViewport(0, 0, render.perspective);
                const reference = transform.projectBasic(unprojected.toArray());
                this._navigator.stateService.zoomIn(delta, reference);
            });
        }
        _disable() {
            this._keyDownSubscription.unsubscribe();
        }
        _getConfiguration(enable) {
            return { keyZoom: enable };
        }
    }

    /**
     * The `KeyPlayHandler` allows the user to control the play behavior
     * using the following key commands:
     *
     * `Spacebar`: Start or stop playing.
     * `SHIFT` + `D`: Switch direction.
     * `<`: Decrease speed.
     * `>`: Increase speed.
     *
     * @example
     * ```js
     * var keyboardComponent = viewer.getComponent("keyboard");
     *
     * keyboardComponent.keyPlay.disable();
     * keyboardComponent.keyPlay.enable();
     *
     * var isEnabled = keyboardComponent.keyPlay.isEnabled;
     * ```
     */
    class KeyPlayHandler extends HandlerBase {
        _enable() {
            this._keyDownSubscription = this._container.keyboardService.keyDown$.pipe(withLatestFrom(this._navigator.playService.playing$, this._navigator.playService.direction$, this._navigator.playService.speed$, this._navigator.stateService.currentImage$.pipe(switchMap((image) => {
                return image.sequenceEdges$;
            })), this._navigator.stateService.state$.pipe(map((state) => {
                return state === State.Earth;
            }), distinctUntilChanged())))
                .subscribe(([event, playing, direction, speed, status, earth]) => {
                if (event.altKey || event.ctrlKey || event.metaKey) {
                    return;
                }
                switch (event.key) {
                    case "D":
                        if (!event.shiftKey) {
                            return;
                        }
                        const newDirection = playing ?
                            null : direction === exports.NavigationDirection.Next ?
                            exports.NavigationDirection.Prev : direction === exports.NavigationDirection.Prev ?
                            exports.NavigationDirection.Next : null;
                        if (newDirection != null) {
                            this._navigator.playService.setDirection(newDirection);
                        }
                        break;
                    case " ":
                        if (event.shiftKey) {
                            return;
                        }
                        if (!earth) {
                            if (playing) {
                                this._navigator.playService.stop();
                            }
                            else {
                                for (let edge of status.edges) {
                                    if (edge.data.direction === direction) {
                                        this._navigator.playService.play();
                                    }
                                }
                            }
                        }
                        break;
                    case "<":
                        this._navigator.playService.setSpeed(speed - 0.05);
                        break;
                    case ">":
                        this._navigator.playService.setSpeed(speed + 0.05);
                        break;
                    default:
                        return;
                }
                event.preventDefault();
            });
        }
        _disable() {
            this._keyDownSubscription.unsubscribe();
        }
        _getConfiguration(enable) {
            return { keyPlay: enable };
        }
    }

    /**
     * @class KeyboardComponent
     *
     * @classdesc Component for keyboard event handling.
     *
     * To retrive and use the keyboard component
     *
     * @example
     * ```js
     * var viewer = new Viewer({ ... });
     *
     * var keyboardComponent = viewer.getComponent("keyboard");
     * ```
     */
    class KeyboardComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._keyPlayHandler =
                new KeyPlayHandler(this, container, navigator);
            this._keySequenceNavigationHandler =
                new KeySequenceNavigationHandler(this, container, navigator);
            this._keySpatialNavigationHandler =
                new KeySpatialNavigationHandler(this, container, navigator, new Spatial());
            this._keyZoomHandler =
                new KeyZoomHandler(this, container, navigator, new ViewportCoords());
        }
        /**
         * Get key play.
         *
         * @returns {KeyPlayHandler} The key play handler.
         */
        get keyPlay() {
            return this._keyPlayHandler;
        }
        /**
         * Get key sequence navigation.
         *
         * @returns {KeySequenceNavigationHandler} The key sequence navigation handler.
         */
        get keySequenceNavigation() {
            return this._keySequenceNavigationHandler;
        }
        /**
         * Get spatial.
         *
         * @returns {KeySpatialNavigationHandler} The spatial handler.
         */
        get keySpatialNavigation() {
            return this._keySpatialNavigationHandler;
        }
        /**
         * Get key zoom.
         *
         * @returns {KeyZoomHandler} The key zoom handler.
         */
        get keyZoom() {
            return this._keyZoomHandler;
        }
        _activate() {
            this._subscriptions.push(this._configuration$
                .subscribe((configuration) => {
                if (configuration.keyPlay) {
                    this._keyPlayHandler.enable();
                }
                else {
                    this._keyPlayHandler.disable();
                }
                if (configuration.keySequenceNavigation) {
                    this._keySequenceNavigationHandler.enable();
                }
                else {
                    this._keySequenceNavigationHandler.disable();
                }
                if (configuration.keySpatialNavigation) {
                    this._keySpatialNavigationHandler.enable();
                }
                else {
                    this._keySpatialNavigationHandler.disable();
                }
                if (configuration.keyZoom) {
                    this._keyZoomHandler.enable();
                }
                else {
                    this._keyZoomHandler.disable();
                }
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
            this._keyPlayHandler.disable();
            this._keySequenceNavigationHandler.disable();
            this._keySpatialNavigationHandler.disable();
            this._keyZoomHandler.disable();
        }
        _getDefaultConfiguration() {
            return { keyPlay: true, keySequenceNavigation: true, keySpatialNavigation: true, keyZoom: true };
        }
    }
    KeyboardComponent.componentName = "keyboard";

    class MarkerScene {
        constructor(scene, raycaster) {
            this._needsRender = false;
            this._interactiveObjects = [];
            this._markers = {};
            this._objectMarkers = {};
            this._raycaster = !!raycaster ? raycaster : new Raycaster();
            this._scene = !!scene ? scene : new Scene();
        }
        get markers() {
            return this._markers;
        }
        get needsRender() {
            return this._needsRender;
        }
        add(marker, position) {
            if (marker.id in this._markers) {
                this._dispose(marker.id);
            }
            marker.createGeometry(position);
            this._scene.add(marker.geometry);
            this._markers[marker.id] = marker;
            for (let interactiveObject of marker.getInteractiveObjects()) {
                this._interactiveObjects.push(interactiveObject);
                this._objectMarkers[interactiveObject.uuid] = marker.id;
            }
            this._needsRender = true;
        }
        clear() {
            for (const id in this._markers) {
                if (!this._markers.hasOwnProperty) {
                    continue;
                }
                this._dispose(id);
            }
            this._needsRender = true;
        }
        get(id) {
            return this._markers[id];
        }
        getAll() {
            return Object
                .keys(this._markers)
                .map((id) => { return this._markers[id]; });
        }
        has(id) {
            return id in this._markers;
        }
        intersectObjects([viewportX, viewportY], camera) {
            this._raycaster.setFromCamera(new Vector2(viewportX, viewportY), camera);
            const intersects = this._raycaster.intersectObjects(this._interactiveObjects);
            for (const intersect of intersects) {
                if (intersect.object.uuid in this._objectMarkers) {
                    return this._objectMarkers[intersect.object.uuid];
                }
            }
            return null;
        }
        lerpAltitude(id, alt, alpha) {
            if (!(id in this._markers)) {
                return;
            }
            this._markers[id].lerpAltitude(alt, alpha);
            this._needsRender = true;
        }
        remove(id) {
            if (!(id in this._markers)) {
                return;
            }
            this._dispose(id);
            this._needsRender = true;
        }
        render(perspectiveCamera, renderer) {
            renderer.render(this._scene, perspectiveCamera);
            this._needsRender = false;
        }
        update(id, position, lngLat) {
            if (!(id in this._markers)) {
                return;
            }
            const marker = this._markers[id];
            marker.updatePosition(position, lngLat);
            this._needsRender = true;
        }
        _dispose(id) {
            const marker = this._markers[id];
            this._scene.remove(marker.geometry);
            for (let interactiveObject of marker.getInteractiveObjects()) {
                const index = this._interactiveObjects.indexOf(interactiveObject);
                if (index !== -1) {
                    this._interactiveObjects.splice(index, 1);
                }
                else {
                    console.warn(`Object does not exist (${interactiveObject.id}) for ${id}`);
                }
                delete this._objectMarkers[interactiveObject.uuid];
            }
            marker.disposeGeometry();
            delete this._markers[id];
        }
    }

    /**
     * @class MarkerComponent
     *
     * @classdesc Component for showing and editing 3D marker objects.
     *
     * The `add` method is used for adding new markers or replacing
     * markers already in the set.
     *
     * If a marker already in the set has the same
     * id as one of the markers added, the old marker will be removed and
     * the added marker will take its place.
     *
     * It is not possible to update markers in the set by updating any properties
     * directly on the marker object. Markers need to be replaced by
     * re-adding them for updates to geographic position or configuration
     * to be reflected.
     *
     * Markers added to the marker component can be either interactive
     * or non-interactive. Different marker types define their behavior.
     * Markers with interaction support can be configured with options
     * to respond to dragging inside the viewer and be detected when
     * retrieving markers from pixel points with the `getMarkerIdAt` method.
     *
     * To retrive and use the marker component
     *
     * @example
     * ```js
     * var viewer = new Viewer({ component: { marker: true }, ... });
     *
     * var markerComponent = viewer.getComponent("marker");
     * ```
     */
    class MarkerComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._graphCalculator = new GraphCalculator();
            this._markerScene = new MarkerScene();
            this._markerSet = new MarkerSet();
            this._viewportCoords = new ViewportCoords();
            this._relativeGroundAltitude = -2;
        }
        /**
         * Add markers to the marker set or replace markers in the marker set.
         *
         * @description If a marker already in the set has the same
         * id as one of the markers added, the old marker will be removed
         * the added marker will take its place.
         *
         * Any marker inside the visible bounding bbox
         * will be initialized and placed in the viewer.
         *
         * @param {Array<Marker>} markers - Markers to add.
         *
         * @example
         * ```js
         * markerComponent.add([marker1, marker2]);
         * ```
         */
        add(markers) {
            this._markerSet.add(markers);
        }
        fire(type, event) {
            super.fire(type, event);
        }
        /**
         * Returns the marker in the marker set with the specified id, or
         * undefined if the id matches no marker.
         *
         * @param {string} markerId - Id of the marker.
         *
         * @example
         * ```js
         * var marker = markerComponent.get("markerId");
         * ```
         *
         */
        get(markerId) {
            return this._markerSet.get(markerId);
        }
        /**
         * Returns an array of all markers.
         *
         * @example
         * ```js
         * var markers = markerComponent.getAll();
         * ```
         */
        getAll() {
            return this._markerSet.getAll();
        }
        /**
         * Returns the id of the interactive marker closest to the current camera
         * position at the specified point.
         *
         * @description Notice that the pixelPoint argument requires x, y
         * coordinates from pixel space.
         *
         * With this function, you can use the coordinates provided by mouse
         * events to get information out of the marker component.
         *
         * If no interactive geometry of an interactive marker exist at the pixel
         * point, `null` will be returned.
         *
         * @param {Array<number>} pixelPoint - Pixel coordinates on the viewer element.
         * @returns {string} Id of the interactive marker closest to the camera. If no
         * interactive marker exist at the pixel point, `null` will be returned.
         *
         * @example
         * ```js
         * markerComponent.getMarkerIdAt([100, 100])
         *     .then((markerId) => { console.log(markerId); });
         * ```
         */
        getMarkerIdAt(pixelPoint) {
            return new Promise((resolve, reject) => {
                this._container.renderService.renderCamera$.pipe(first(), map((render) => {
                    const viewport = this._viewportCoords
                        .canvasToViewport(pixelPoint[0], pixelPoint[1], this._container.container);
                    const id = this._markerScene.intersectObjects(viewport, render.perspective);
                    return id;
                }))
                    .subscribe((id) => {
                    resolve(id);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Check if a marker exist in the marker set.
         *
         * @param {string} markerId - Id of the marker.
         *
         * @example
         * ```js
         * var markerExists = markerComponent.has("markerId");
         * ```
         */
        has(markerId) {
            return this._markerSet.has(markerId);
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Remove markers with the specified ids from the marker set.
         *
         * @param {Array<string>} markerIds - Ids for markers to remove.
         *
         * @example
         * ```js
         * markerComponent.remove(["id-1", "id-2"]);
         * ```
         */
        remove(markerIds) {
            this._markerSet.remove(markerIds);
        }
        /**
         * Remove all markers from the marker set.
         *
         * @example
         * ```js
         * markerComponent.removeAll();
         * ```
         */
        removeAll() {
            this._markerSet.removeAll();
        }
        _activate() {
            const groundAltitude$ = this._navigator.stateService.currentState$.pipe(map((frame) => {
                return frame.state.camera.position.z + this._relativeGroundAltitude;
            }), distinctUntilChanged((a1, a2) => {
                return Math.abs(a1 - a2) < 0.01;
            }), publishReplay(1), refCount());
            const geoInitiated$ = combineLatest(groundAltitude$, this._navigator.stateService.reference$).pipe(first(), map(() => { }), publishReplay(1), refCount());
            const clampedConfiguration$ = this._configuration$.pipe(map((configuration) => {
                return { visibleBBoxSize: Math.max(1, Math.min(200, configuration.visibleBBoxSize)) };
            }));
            const currentLngLat$ = this._navigator.stateService.currentImage$.pipe(map((image) => { return image.lngLat; }), publishReplay(1), refCount());
            const visibleBBox$ = combineLatest(clampedConfiguration$, currentLngLat$).pipe(map(([configuration, lngLat]) => {
                return this._graphCalculator
                    .boundingBoxCorners(lngLat, configuration.visibleBBoxSize / 2);
            }), publishReplay(1), refCount());
            const visibleMarkers$ = combineLatest(concat(of(this._markerSet), this._markerSet.changed$), visibleBBox$).pipe(map(([set, bbox]) => {
                return set.search(bbox);
            }));
            const subs = this._subscriptions;
            subs.push(geoInitiated$.pipe(switchMap(() => {
                return visibleMarkers$.pipe(withLatestFrom(this._navigator.stateService.reference$, groundAltitude$));
            }))
                .subscribe(([markers, reference, alt]) => {
                const markerScene = this._markerScene;
                const sceneMarkers = markerScene.markers;
                const markersToRemove = Object.assign({}, sceneMarkers);
                for (const marker of markers) {
                    if (marker.id in sceneMarkers) {
                        delete markersToRemove[marker.id];
                    }
                    else {
                        const point3d = geodeticToEnu(marker.lngLat.lng, marker.lngLat.lat, reference.alt + alt, reference.lng, reference.lat, reference.alt);
                        markerScene.add(marker, point3d);
                    }
                }
                for (const id in markersToRemove) {
                    if (!markersToRemove.hasOwnProperty(id)) {
                        continue;
                    }
                    markerScene.remove(id);
                }
            }));
            subs.push(geoInitiated$.pipe(switchMap(() => {
                return this._markerSet.updated$.pipe(withLatestFrom(visibleBBox$, this._navigator.stateService.reference$, groundAltitude$));
            }))
                .subscribe(([markers, [sw, ne], reference, alt]) => {
                const markerScene = this._markerScene;
                for (const marker of markers) {
                    const exists = markerScene.has(marker.id);
                    const visible = marker.lngLat.lat > sw.lat &&
                        marker.lngLat.lat < ne.lat &&
                        marker.lngLat.lng > sw.lng &&
                        marker.lngLat.lng < ne.lng;
                    if (visible) {
                        const point3d = geodeticToEnu(marker.lngLat.lng, marker.lngLat.lat, reference.alt + alt, reference.lng, reference.lat, reference.alt);
                        markerScene.add(marker, point3d);
                    }
                    else if (!visible && exists) {
                        markerScene.remove(marker.id);
                    }
                }
            }));
            subs.push(this._navigator.stateService.reference$.pipe(skip(1), withLatestFrom(groundAltitude$))
                .subscribe(([reference, alt]) => {
                const markerScene = this._markerScene;
                for (const marker of markerScene.getAll()) {
                    const point3d = geodeticToEnu(marker.lngLat.lng, marker.lngLat.lat, reference.alt + alt, reference.lng, reference.lat, reference.alt);
                    markerScene.update(marker.id, point3d);
                }
            }));
            subs.push(groundAltitude$.pipe(skip(1), withLatestFrom(this._navigator.stateService.reference$, currentLngLat$))
                .subscribe(([alt, reference, lngLat]) => {
                const markerScene = this._markerScene;
                const position = geodeticToEnu(lngLat.lng, lngLat.lat, reference.alt + alt, reference.lng, reference.lat, reference.alt);
                for (const marker of markerScene.getAll()) {
                    const point3d = geodeticToEnu(marker.lngLat.lng, marker.lngLat.lat, reference.alt + alt, reference.lng, reference.lat, reference.alt);
                    const distanceX = point3d[0] - position[0];
                    const distanceY = point3d[1] - position[1];
                    const groundDistance = Math
                        .sqrt(distanceX * distanceX + distanceY * distanceY);
                    if (groundDistance > 50) {
                        continue;
                    }
                    markerScene.lerpAltitude(marker.id, alt, Math.min(1, Math.max(0, 1.2 - 1.2 * groundDistance / 50)));
                }
            }));
            subs.push(this._navigator.stateService.currentState$
                .pipe(map((frame) => {
                const scene = this._markerScene;
                return {
                    name: this._name,
                    renderer: {
                        frameId: frame.id,
                        needsRender: scene.needsRender,
                        render: scene.render.bind(scene),
                        pass: RenderPass.Opaque,
                    },
                };
            }))
                .subscribe(this._container.glRenderer.render$));
            const hoveredMarkerId$ = combineLatest(this._container.renderService.renderCamera$, this._container.mouseService.mouseMove$)
                .pipe(map(([render, event]) => {
                const element = this._container.container;
                const [canvasX, canvasY] = this._viewportCoords.canvasPosition(event, element);
                const viewport = this._viewportCoords
                    .canvasToViewport(canvasX, canvasY, element);
                const markerId = this._markerScene.intersectObjects(viewport, render.perspective);
                return markerId;
            }), publishReplay(1), refCount());
            const draggingStarted$ = this._container.mouseService
                .filtered$(this._name, this._container.mouseService.mouseDragStart$).pipe(map(() => {
                return true;
            }));
            const draggingStopped$ = this._container.mouseService
                .filtered$(this._name, this._container.mouseService.mouseDragEnd$).pipe(map(() => {
                return false;
            }));
            const filteredDragging$ = merge(draggingStarted$, draggingStopped$)
                .pipe(startWith(false));
            subs.push(merge(draggingStarted$.pipe(withLatestFrom(hoveredMarkerId$)), combineLatest(draggingStopped$, of(null))).pipe(startWith([false, null]), pairwise())
                .subscribe(([previous, current]) => {
                const dragging = current[0];
                const type = dragging ?
                    "markerdragstart" :
                    "markerdragend";
                const id = dragging ? current[1] : previous[1];
                const marker = this._markerScene.get(id);
                const event = {
                    marker,
                    target: this,
                    type,
                };
                this.fire(type, event);
            }));
            const mouseDown$ = merge(this._container.mouseService.mouseDown$.pipe(map(() => { return true; })), this._container.mouseService.documentMouseUp$.pipe(map(() => { return false; }))).pipe(startWith(false));
            subs.push(combineLatest(this._container.mouseService.active$, hoveredMarkerId$.pipe(distinctUntilChanged()), mouseDown$, filteredDragging$)
                .pipe(map(([active, markerId, mouseDown, filteredDragging]) => {
                return (!active && markerId != null && mouseDown) ||
                    filteredDragging;
            }), distinctUntilChanged())
                .subscribe((claim) => {
                if (claim) {
                    this._container.mouseService.claimMouse(this._name, 1);
                    this._container.mouseService.claimWheel(this._name, 1);
                }
                else {
                    this._container.mouseService.unclaimMouse(this._name);
                    this._container.mouseService.unclaimWheel(this._name);
                }
            }));
            const offset$ = this._container.mouseService
                .filtered$(this._name, this._container.mouseService.mouseDragStart$).pipe(withLatestFrom(hoveredMarkerId$, this._container.renderService.renderCamera$), map(([e, id, r]) => {
                const marker = this._markerScene.get(id);
                const element = this._container.container;
                const [groundCanvasX, groundCanvasY] = this._viewportCoords
                    .projectToCanvas(marker.geometry.position
                    .toArray(), element, r.perspective);
                const [canvasX, canvasY] = this._viewportCoords
                    .canvasPosition(e, element);
                const offset = [canvasX - groundCanvasX, canvasY - groundCanvasY];
                return [marker, offset, r];
            }), publishReplay(1), refCount());
            subs.push(this._container.mouseService
                .filtered$(this._name, this._container.mouseService.mouseDrag$)
                .pipe(withLatestFrom(offset$, this._navigator.stateService.reference$, clampedConfiguration$))
                .subscribe(([event, [marker, offset, render], reference, configuration]) => {
                if (!this._markerScene.has(marker.id)) {
                    return;
                }
                const element = this._container.container;
                const [canvasX, canvasY] = this._viewportCoords
                    .canvasPosition(event, element);
                const groundX = canvasX - offset[0];
                const groundY = canvasY - offset[1];
                const [viewportX, viewportY] = this._viewportCoords
                    .canvasToViewport(groundX, groundY, element);
                const direction = new Vector3(viewportX, viewportY, 1)
                    .unproject(render.perspective)
                    .sub(render.perspective.position)
                    .normalize();
                const distance = Math.min(this._relativeGroundAltitude / direction.z, configuration.visibleBBoxSize / 2 - 0.1);
                if (distance < 0) {
                    return;
                }
                const intersection = direction
                    .clone()
                    .multiplyScalar(distance)
                    .add(render.perspective.position);
                intersection.z =
                    render.perspective.position.z
                        + this._relativeGroundAltitude;
                const [lng, lat] = enuToGeodetic(intersection.x, intersection.y, intersection.z, reference.lng, reference.lat, reference.alt);
                this._markerScene
                    .update(marker.id, intersection.toArray(), { lat, lng });
                this._markerSet.update(marker);
                const type = "markerposition";
                const markerEvent = {
                    marker,
                    target: this,
                    type,
                };
                this.fire(type, markerEvent);
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
            this._markerScene.clear();
        }
        _getDefaultConfiguration() {
            return { visibleBBoxSize: 100 };
        }
    }
    MarkerComponent.componentName = "marker";

    function sign$1(n) {
        return n > 0 ? 1 : n < 0 ? -1 : 0;
    }
    function colinearPointOnSegment(p, s) {
        return p.x <= Math.max(s.p1.x, s.p2.x) &&
            p.x >= Math.min(s.p1.x, s.p2.x) &&
            p.y >= Math.max(s.p1.y, s.p2.y) &&
            p.y >= Math.min(s.p1.y, s.p2.y);
    }
    function parallel(s1, s2) {
        const ux = s1.p2.x - s1.p1.x;
        const uy = s1.p2.y - s1.p1.y;
        const vx = s2.p2.x - s2.p1.x;
        const vy = s2.p2.y - s2.p1.y;
        const cross = ux * vy - uy * vx;
        const u2 = ux * ux + uy * uy;
        const v2 = vx * vx + vy * vy;
        const epsilon2 = 1e-10;
        return cross * cross < epsilon2 * u2 * v2;
    }
    function tripletOrientation(p1, p2, p3) {
        const orientation = (p2.y - p1.y) * (p3.x - p2.x) -
            (p3.y - p2.y) * (p2.x - p1.x);
        return sign$1(orientation);
    }
    function segmentsIntersect(s1, s2) {
        if (parallel(s1, s2)) {
            return false;
        }
        const o1 = tripletOrientation(s1.p1, s1.p2, s2.p1);
        const o2 = tripletOrientation(s1.p1, s1.p2, s2.p2);
        const o3 = tripletOrientation(s2.p1, s2.p2, s1.p1);
        const o4 = tripletOrientation(s2.p1, s2.p2, s1.p2);
        if (o1 !== o2 && o3 !== o4) {
            return true;
        }
        if (o1 === 0 && colinearPointOnSegment(s2.p1, s1)) {
            return true;
        }
        if (o2 === 0 && colinearPointOnSegment(s2.p2, s1)) {
            return true;
        }
        if (o3 === 0 && colinearPointOnSegment(s1.p1, s2)) {
            return true;
        }
        if (o4 === 0 && colinearPointOnSegment(s1.p2, s2)) {
            return true;
        }
        return false;
    }
    function segmentIntersection(s1, s2) {
        if (parallel(s1, s2)) {
            return undefined;
        }
        const x1 = s1.p1.x;
        const x2 = s1.p2.x;
        const y1 = s1.p1.y;
        const y2 = s1.p2.y;
        const x3 = s2.p1.x;
        const x4 = s2.p2.x;
        const y3 = s2.p1.y;
        const y4 = s2.p2.y;
        const den = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
        const xNum = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4);
        const yNum = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4);
        return { x: xNum / den, y: yNum / den };
    }

    function basicBoundaryPoints(pointsPerSide) {
        let points = [];
        let os = [[0, 0], [1, 0], [1, 1], [0, 1]];
        let ds = [[1, 0], [0, 1], [-1, 0], [0, -1]];
        for (let side = 0; side < 4; ++side) {
            let o = os[side];
            let d = ds[side];
            for (let i = 0; i < pointsPerSide; ++i) {
                points.push([o[0] + d[0] * i / pointsPerSide,
                    o[1] + d[1] * i / pointsPerSide]);
            }
        }
        return points;
    }
    function insideViewport(x, y) {
        return x >= -1 && x <= 1 && y >= -1 && y <= 1;
    }
    function insideBasic(x, y) {
        return x >= 0 && x <= 1 && y >= 0 && y <= 1;
    }
    function viewportDistances(transform, perspective, viewportCoords) {
        const boundaryPointsBasic = basicBoundaryPoints(100);
        const boundaryPointsViewport = boundaryPointsBasic
            .map((basic) => {
            return viewportCoords.basicToViewportSafe(basic[0], basic[1], transform, perspective);
        });
        const visibleBoundaryPoints = [];
        const viewportSides = [
            { x: -1, y: 1 },
            { x: 1, y: 1 },
            { x: 1, y: -1 },
            { x: -1, y: -1 }
        ];
        const intersections = [false, false, false, false];
        for (let i = 0; i < boundaryPointsViewport.length; i++) {
            const p1 = boundaryPointsViewport[i];
            const p2 = boundaryPointsViewport[(i + 1) % boundaryPointsViewport.length];
            if (p1 === null) {
                continue;
            }
            if (p2 === null) {
                if (insideViewport(p1[0], p1[1])) {
                    visibleBoundaryPoints.push(p1);
                }
                continue;
            }
            const [x1, y1] = p1;
            const [x2, y2] = p2;
            if (insideViewport(x1, y1)) {
                if (insideViewport(x2, y2)) {
                    visibleBoundaryPoints.push(p1);
                }
                else {
                    for (let side = 0; side < 4; side++) {
                        const s1 = { p1: { x: x1, y: y1 }, p2: { x: x2, y: y2 } };
                        const s2 = { p1: viewportSides[side], p2: viewportSides[(side + 1) % 4] };
                        const intersecting = segmentsIntersect(s1, s2);
                        if (intersecting) {
                            const intersection = segmentIntersection(s1, s2);
                            visibleBoundaryPoints.push(p1, [intersection.x, intersection.y]);
                            intersections[side] = true;
                        }
                    }
                }
            }
        }
        const [topLeftBasicX, topLeftBasicY] = viewportCoords.viewportToBasic(-1, 1, transform, perspective);
        const [topRightBasicX, topRightBasicY] = viewportCoords.viewportToBasic(1, 1, transform, perspective);
        const [bottomRightBasicX, bottomRightBasicY] = viewportCoords.viewportToBasic(1, -1, transform, perspective);
        const [bottomLeftBasicX, bottomLeftBasicY] = viewportCoords.viewportToBasic(-1, -1, transform, perspective);
        if (insideBasic(topLeftBasicX, topLeftBasicY)) {
            intersections[3] = intersections[0] = true;
        }
        if (insideBasic(topRightBasicX, topRightBasicY)) {
            intersections[0] = intersections[1] = true;
        }
        if (insideBasic(bottomRightBasicX, bottomRightBasicY)) {
            intersections[1] = intersections[2] = true;
        }
        if (insideBasic(bottomLeftBasicX, bottomLeftBasicY)) {
            intersections[2] = intersections[3] = true;
        }
        const maximums = [-1, -1, 1, 1];
        for (let visibleBoundaryPoint of visibleBoundaryPoints) {
            const x = visibleBoundaryPoint[0];
            const y = visibleBoundaryPoint[1];
            if (x > maximums[1]) {
                maximums[1] = x;
            }
            if (x < maximums[3]) {
                maximums[3] = x;
            }
            if (y > maximums[0]) {
                maximums[0] = y;
            }
            if (y < maximums[2]) {
                maximums[2] = y;
            }
        }
        const boundary = [1, 1, -1, -1];
        const distances = [];
        for (let side = 0; side < 4; side++) {
            if (intersections[side]) {
                distances.push(0);
                continue;
            }
            distances.push(Math.abs(boundary[side] - maximums[side]));
        }
        return distances;
    }

    /**
     * The `BounceHandler` ensures that the viewer bounces back to the image
     * when drag panning outside of the image edge.
     */
    class BounceHandler extends HandlerBase {
        constructor(component, container, navigator, viewportCoords, spatial) {
            super(component, container, navigator);
            this._spatial = spatial;
            this._viewportCoords = viewportCoords;
        }
        _enable() {
            const inTransition$ = this._navigator.stateService.currentState$.pipe(map((frame) => {
                return frame.state.alpha < 1;
            }), distinctUntilChanged());
            this._bounceSubscription = combineLatest(inTransition$, this._navigator.stateService.inTranslation$, this._container.mouseService.active$, this._container.touchService.active$).pipe(map((noForce) => {
                return noForce[0] || noForce[1] || noForce[2] || noForce[3];
            }), distinctUntilChanged(), switchMap((noForce) => {
                return noForce ?
                    empty() :
                    combineLatest(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$.pipe(first()));
            }), withLatestFrom(this._navigator.panService.panImages$))
                .subscribe(([[render, transform], nts]) => {
                if (!transform.hasValidScale && render.camera.focal < 0.1) {
                    return;
                }
                if (render.perspective.aspect === 0 || render.perspective.aspect === Number.POSITIVE_INFINITY) {
                    return;
                }
                const distances = viewportDistances(transform, render.perspective, this._viewportCoords);
                const basic = this._viewportCoords.viewportToBasic(0, 0, transform, render.perspective);
                if ((basic[0] < 0 || basic[0] > 1) && nts.length > 0) {
                    distances[0] = distances[2] = 0;
                }
                for (const [, t] of nts) {
                    const d = viewportDistances(t, render.perspective, this._viewportCoords);
                    for (let i = 1; i < distances.length; i += 2) {
                        if (d[i] < distances[i]) {
                            distances[i] = d[i];
                        }
                    }
                }
                if (Math.max(...distances) < 0.01) {
                    return;
                }
                const horizontalDistance = distances[1] - distances[3];
                const verticalDistance = distances[0] - distances[2];
                const currentDirection = this._viewportCoords
                    .unprojectFromViewport(0, 0, render.perspective)
                    .sub(render.perspective.position);
                const directionPhi = this._viewportCoords
                    .unprojectFromViewport(horizontalDistance, 0, render.perspective)
                    .sub(render.perspective.position);
                const directionTheta = this._viewportCoords
                    .unprojectFromViewport(0, verticalDistance, render.perspective)
                    .sub(render.perspective.position);
                let phi = (horizontalDistance > 0 ? 1 : -1) * directionPhi.angleTo(currentDirection);
                let theta = (verticalDistance > 0 ? 1 : -1) * directionTheta.angleTo(currentDirection);
                const threshold = Math.PI / 60;
                const coeff = 1e-1;
                phi = this._spatial.clamp(coeff * phi, -threshold, threshold);
                theta = this._spatial.clamp(coeff * theta, -threshold, threshold);
                this._navigator.stateService.rotateUnbounded({ phi: phi, theta: theta });
            });
        }
        _disable() {
            this._bounceSubscription.unsubscribe();
        }
        _getConfiguration() {
            return {};
        }
    }

    class MouseOperator {
        static filteredPairwiseMouseDrag$(name, mouseService) {
            return this._filteredPairwiseMouseDrag$(name, mouseService, mouseService.mouseDragStart$, mouseService.mouseDrag$, mouseService.mouseDragEnd$);
        }
        static filteredPairwiseMouseRightDrag$(name, mouseService) {
            return this._filteredPairwiseMouseDrag$(name, mouseService, mouseService.mouseRightDragStart$, mouseService.mouseRightDrag$, mouseService.mouseRightDragEnd$);
        }
        static _filteredPairwiseMouseDrag$(name, mouseService, mouseDragStart$, mouseDrag$, mouseDragEnd$) {
            return mouseService
                .filtered$(name, mouseDragStart$).pipe(switchMap((mouseDragStart) => {
                const dragging$ = concat(of(mouseDragStart), mouseService
                    .filtered$(name, mouseDrag$));
                const dragEnd$ = mouseService
                    .filtered$(name, mouseDragEnd$).pipe(map(() => {
                    return null;
                }));
                return merge(dragging$, dragEnd$).pipe(takeWhile((e) => {
                    return !!e;
                }), startWith(null));
            }), pairwise(), filter((pair) => {
                return pair[0] != null && pair[1] != null;
            }));
        }
    }

    /**
     * The `DragPanHandler` allows the user to pan the viewer image by clicking and dragging the cursor.
     *
     * @example
     * ```js
     * var pointerComponent = viewer.getComponent("pointer");
     *
     * pointerComponent.dragPan.disable();
     * pointerComponent.dragPan.enable();
     *
     * var isEnabled = pointerComponent.dragPan.isEnabled;
     * ```
     */
    class DragPanHandler extends HandlerBase {
        /** @ignore */
        constructor(component, container, navigator, viewportCoords, spatial) {
            super(component, container, navigator);
            this._spatial = spatial;
            this._viewportCoords = viewportCoords;
        }
        _enable() {
            let draggingStarted$ = this._container.mouseService
                .filtered$(this._component.name, this._container.mouseService.mouseDragStart$).pipe(map(() => {
                return true;
            }), share());
            let draggingStopped$ = this._container.mouseService
                .filtered$(this._component.name, this._container.mouseService.mouseDragEnd$).pipe(map(() => {
                return false;
            }), share());
            this._activeMouseSubscription = merge(draggingStarted$, draggingStopped$)
                .subscribe(this._container.mouseService.activate$);
            const documentMouseMove$ = merge(draggingStarted$, draggingStopped$).pipe(switchMap((dragging) => {
                return dragging ?
                    this._container.mouseService.documentMouseMove$ :
                    empty();
            }));
            this._preventDefaultSubscription = merge(documentMouseMove$, this._container.touchService.touchMove$)
                .subscribe((event) => {
                event.preventDefault(); // prevent selection of content outside the viewer
            });
            let touchMovingStarted$ = this._container.touchService.singleTouchDragStart$.pipe(map(() => {
                return true;
            }));
            let touchMovingStopped$ = this._container.touchService.singleTouchDragEnd$.pipe(map(() => {
                return false;
            }));
            this._activeTouchSubscription = merge(touchMovingStarted$, touchMovingStopped$)
                .subscribe(this._container.touchService.activate$);
            const rotation$ = this._navigator.stateService.currentState$.pipe(map((frame) => {
                return isSpherical(frame.state.currentImage.cameraType) ||
                    frame.state.imagesAhead < 1;
            }), distinctUntilChanged(), switchMap((enable) => {
                if (!enable) {
                    return empty();
                }
                const mouseDrag$ = MouseOperator.filteredPairwiseMouseDrag$(this._component.name, this._container.mouseService);
                const singleTouchDrag$ = merge(this._container.touchService.singleTouchDragStart$, this._container.touchService.singleTouchDrag$, this._container.touchService.singleTouchDragEnd$.pipe(map(() => { return null; }))).pipe(map((event) => {
                    return event != null && event.touches.length > 0 ?
                        event.touches[0] : null;
                }), pairwise(), filter((pair) => {
                    return pair[0] != null && pair[1] != null;
                }));
                return merge(mouseDrag$, singleTouchDrag$);
            }), withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$, this._navigator.panService.panImages$), map(([events, render, transform, nts]) => {
                let previousEvent = events[0];
                let event = events[1];
                let movementX = event.clientX - previousEvent.clientX;
                let movementY = event.clientY - previousEvent.clientY;
                let element = this._container.container;
                let [canvasX, canvasY] = this._viewportCoords.canvasPosition(event, element);
                let currentDirection = this._viewportCoords.unprojectFromCanvas(canvasX, canvasY, element, render.perspective)
                    .sub(render.perspective.position);
                let directionX = this._viewportCoords.unprojectFromCanvas(canvasX - movementX, canvasY, element, render.perspective)
                    .sub(render.perspective.position);
                let directionY = this._viewportCoords.unprojectFromCanvas(canvasX, canvasY - movementY, element, render.perspective)
                    .sub(render.perspective.position);
                let phi = (movementX > 0 ? 1 : -1) * directionX.angleTo(currentDirection);
                let theta = (movementY > 0 ? -1 : 1) * directionY.angleTo(currentDirection);
                const distances = viewportDistances(transform, render.perspective, this._viewportCoords);
                for (const [, t] of nts) {
                    const d = viewportDistances(t, render.perspective, this._viewportCoords);
                    for (let i = 0; i < distances.length; i++) {
                        if (d[i] < distances[i]) {
                            distances[i] = d[i];
                        }
                    }
                }
                if (distances[0] > 0 && theta < 0) {
                    theta /= Math.max(1, 2e2 * distances[0]);
                }
                if (distances[2] > 0 && theta > 0) {
                    theta /= Math.max(1, 2e2 * distances[2]);
                }
                if (distances[1] > 0 && phi < 0) {
                    phi /= Math.max(1, 2e2 * distances[1]);
                }
                if (distances[3] > 0 && phi > 0) {
                    phi /= Math.max(1, 2e2 * distances[3]);
                }
                return { phi: phi, theta: theta };
            }), share());
            this._rotateWithoutInertiaSubscription = rotation$
                .subscribe((rotation) => {
                this._navigator.stateService.rotateWithoutInertia(rotation);
            });
            this._rotateSubscription = rotation$.pipe(scan((rotationBuffer, rotation) => {
                this._drainBuffer(rotationBuffer);
                rotationBuffer.push([Date.now(), rotation]);
                return rotationBuffer;
            }, []), sample(merge(this._container.mouseService.filtered$(this._component.name, this._container.mouseService.mouseDragEnd$), this._container.touchService.singleTouchDragEnd$)), map((rotationBuffer) => {
                const drainedBuffer = this._drainBuffer(rotationBuffer.slice());
                const rotation = { phi: 0, theta: 0 };
                for (const bufferedRotation of drainedBuffer) {
                    rotation.phi += bufferedRotation[1].phi;
                    rotation.theta += bufferedRotation[1].theta;
                }
                const count = drainedBuffer.length;
                if (count > 0) {
                    rotation.phi /= count;
                    rotation.theta /= count;
                }
                const threshold = Math.PI / 18;
                rotation.phi = this._spatial.clamp(rotation.phi, -threshold, threshold);
                rotation.theta = this._spatial.clamp(rotation.theta, -threshold, threshold);
                return rotation;
            }))
                .subscribe((rotation) => {
                this._navigator.stateService.rotate(rotation);
            });
        }
        _disable() {
            this._activeMouseSubscription.unsubscribe();
            this._activeTouchSubscription.unsubscribe();
            this._preventDefaultSubscription.unsubscribe();
            this._rotateSubscription.unsubscribe();
            this._rotateWithoutInertiaSubscription.unsubscribe();
            this._activeMouseSubscription = null;
            this._activeTouchSubscription = null;
            this._preventDefaultSubscription = null;
            this._rotateSubscription = null;
        }
        _getConfiguration(enable) {
            return { dragPan: enable };
        }
        _drainBuffer(buffer) {
            const cutoff = 50;
            const now = Date.now();
            while (buffer.length > 0 && now - buffer[0][0] > cutoff) {
                buffer.shift();
            }
            return buffer;
        }
    }

    class EarthControlHandler extends HandlerBase {
        /** @ignore */
        constructor(component, container, navigator, viewportCoords, spatial) {
            super(component, container, navigator);
            this._spatial = spatial;
            this._viewportCoords = viewportCoords;
            this._subscriptions = new SubscriptionHolder();
        }
        _enable() {
            const earth$ = this._navigator.stateService.state$.pipe(map((state) => {
                return state === State.Earth;
            }), publishReplay(1), refCount());
            const subs = this._subscriptions;
            subs.push(earth$.pipe(switchMap((earth) => {
                return earth ?
                    this._container.mouseService.mouseWheel$ :
                    empty();
            }))
                .subscribe((event) => {
                event.preventDefault();
            }));
            subs.push(earth$.pipe(switchMap((earth) => {
                if (!earth) {
                    return empty();
                }
                return MouseOperator.filteredPairwiseMouseDrag$(this._component.name, this._container.mouseService).pipe(filter(([e1, e2]) => {
                    return !(e1.ctrlKey && e2.ctrlKey);
                }));
            }), withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$), map(([[previous, current], render, transform]) => {
                const planeNormal = [0, 0, 1];
                const planePoint = [0, 0, -2];
                const currentIntersection = this._planeIntersection(current, planeNormal, planePoint, render.perspective, this._container.container);
                const previousIntersection = this._planeIntersection(previous, planeNormal, planePoint, render.perspective, this._container.container);
                if (!currentIntersection || !previousIntersection) {
                    return null;
                }
                const direction = new Vector3()
                    .subVectors(currentIntersection, previousIntersection)
                    .multiplyScalar(-1)
                    .toArray();
                return direction;
            }), filter((direction) => {
                return !!direction;
            }))
                .subscribe((direction) => {
                this._navigator.stateService.truck(direction);
            }));
            subs.push(earth$.pipe(switchMap((earth) => {
                if (!earth) {
                    return empty();
                }
                return MouseOperator.filteredPairwiseMouseDrag$(this._component.name, this._container.mouseService).pipe(filter(([e1, e2]) => {
                    return e1.ctrlKey && e2.ctrlKey;
                }));
            }), map(([previous, current]) => {
                return this._mousePairToRotation(previous, current);
            }))
                .subscribe((rotation) => {
                this._navigator.stateService.orbit(rotation);
            }));
            subs.push(earth$.pipe(switchMap((earth) => {
                if (!earth) {
                    return empty();
                }
                return MouseOperator.filteredPairwiseMouseRightDrag$(this._component.name, this._container.mouseService).pipe(filter(([e1, e2]) => {
                    return !e1.ctrlKey && !e2.ctrlKey;
                }));
            }), map(([previous, current]) => {
                return this._mousePairToRotation(previous, current);
            }))
                .subscribe((rotation) => {
                this._navigator.stateService.orbit(rotation);
            }));
            subs.push(earth$.pipe(switchMap((earth) => {
                if (!earth) {
                    return empty();
                }
                return this._container.mouseService
                    .filteredWheel$(this._component.name, this._container.mouseService.mouseWheel$);
            }), map((event) => {
                let delta = event.deltaY;
                if (event.deltaMode === 1) {
                    delta = 40 * delta;
                }
                else if (event.deltaMode === 2) {
                    delta = 800 * delta;
                }
                const canvasSize = this._viewportCoords.containerToCanvas(this._container.container);
                return -delta / canvasSize[1];
            }))
                .subscribe((delta) => {
                this._navigator.stateService.dolly(delta);
            }));
        }
        _disable() {
            this._subscriptions.unsubscribe();
        }
        _getConfiguration() {
            return {};
        }
        _eventToViewport(event, element) {
            const previousCanvas = this._viewportCoords.canvasPosition(event, element);
            return this._viewportCoords.canvasToViewport(previousCanvas[0], previousCanvas[1], element);
        }
        _mousePairToRotation(previous, current) {
            const [currentX, currentY] = this._eventToViewport(current, this._container.container);
            const [previousX, previousY] = this._eventToViewport(previous, this._container.container);
            const phi = (previousX - currentX) * Math.PI;
            const theta = (currentY - previousY) * Math.PI / 2;
            return { phi: phi, theta: theta };
        }
        _planeIntersection(event, planeNormal, planePoint, camera, element) {
            const [canvasX, canvasY] = this._viewportCoords.canvasPosition(event, element);
            const direction = this._viewportCoords
                .unprojectFromCanvas(canvasX, canvasY, element, camera)
                .sub(camera.position)
                .normalize();
            if (Math.abs(this._spatial.angleToPlane(direction.toArray(), planeNormal)) < Math.PI / 90) {
                return null;
            }
            const l0 = camera.position.clone();
            const n = new Vector3().fromArray(planeNormal);
            const p0 = new Vector3().fromArray(planePoint);
            const d = new Vector3().subVectors(p0, l0).dot(n) / direction.clone().dot(n);
            const intersection = new Vector3().addVectors(l0, direction.multiplyScalar(d));
            if (this._viewportCoords.worldToCamera(intersection.toArray(), camera)[2] > 0) {
                return null;
            }
            return intersection;
        }
    }

    /**
     * The `ScrollZoomHandler` allows the user to zoom the viewer image by scrolling.
     *
     * @example
     * ```js
     * var pointerComponent = viewer.getComponent("pointer");
     *
     * pointerComponent.scrollZoom.disable();
     * pointerComponent.scrollZoom.enable();
     *
     * var isEnabled = pointerComponent.scrollZoom.isEnabled;
     * ```
     */
    class ScrollZoomHandler extends HandlerBase {
        /** @ignore */
        constructor(component, container, navigator, viewportCoords) {
            super(component, container, navigator);
            this._viewportCoords = viewportCoords;
        }
        _enable() {
            this._container.mouseService.claimWheel(this._component.name, 0);
            this._preventDefaultSubscription = this._container.mouseService.mouseWheel$
                .subscribe((event) => {
                event.preventDefault();
            });
            this._zoomSubscription = this._container.mouseService
                .filteredWheel$(this._component.name, this._container.mouseService.mouseWheel$).pipe(withLatestFrom(this._navigator.stateService.currentState$, (w, f) => {
                return [w, f];
            }), filter((args) => {
                let state = args[1].state;
                return isSpherical(state.currentImage.cameraType) ||
                    state.imagesAhead < 1;
            }), map((args) => {
                return args[0];
            }), withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$, (w, r, t) => {
                return [w, r, t];
            }))
                .subscribe((args) => {
                let event = args[0];
                let render = args[1];
                let transform = args[2];
                let element = this._container.container;
                let [canvasX, canvasY] = this._viewportCoords.canvasPosition(event, element);
                let unprojected = this._viewportCoords.unprojectFromCanvas(canvasX, canvasY, element, render.perspective);
                let reference = transform.projectBasic(unprojected.toArray());
                let deltaY = event.deltaY;
                if (event.deltaMode === 1) {
                    deltaY = 40 * deltaY;
                }
                else if (event.deltaMode === 2) {
                    deltaY = 800 * deltaY;
                }
                const canvasSize = this._viewportCoords.containerToCanvas(element);
                let zoom = -3 * deltaY / canvasSize[1];
                this._navigator.stateService.zoomIn(zoom, reference);
            });
        }
        _disable() {
            this._container.mouseService.unclaimWheel(this._component.name);
            this._preventDefaultSubscription.unsubscribe();
            this._zoomSubscription.unsubscribe();
            this._preventDefaultSubscription = null;
            this._zoomSubscription = null;
        }
        _getConfiguration(enable) {
            return { scrollZoom: enable };
        }
    }

    /**
     * The `TouchZoomHandler` allows the user to zoom the viewer image by pinching on a touchscreen.
     *
     * @example
     * ```js
     * var pointerComponent = viewer.getComponent("pointer");
     *
     * pointerComponent.touchZoom.disable();
     * pointerComponent.touchZoom.enable();
     *
     * var isEnabled = pointerComponent.touchZoom.isEnabled;
     * ```
     */
    class TouchZoomHandler extends HandlerBase {
        /** @ignore */
        constructor(component, container, navigator, viewportCoords) {
            super(component, container, navigator);
            this._viewportCoords = viewportCoords;
        }
        _enable() {
            this._preventDefaultSubscription = this._container.touchService.pinch$
                .subscribe((pinch) => {
                pinch.originalEvent.preventDefault();
            });
            let pinchStarted$ = this._container.touchService.pinchStart$.pipe(map((event) => {
                return true;
            }));
            let pinchStopped$ = this._container.touchService.pinchEnd$.pipe(map((event) => {
                return false;
            }));
            this._activeSubscription = merge(pinchStarted$, pinchStopped$)
                .subscribe(this._container.touchService.activate$);
            this._zoomSubscription = this._container.touchService.pinch$.pipe(withLatestFrom(this._navigator.stateService.currentState$), filter((args) => {
                let state = args[1].state;
                return isSpherical(state.currentImage.cameraType) ||
                    state.imagesAhead < 1;
            }), map((args) => {
                return args[0];
            }), withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$))
                .subscribe(([pinch, render, transform]) => {
                let element = this._container.container;
                let [canvasX, canvasY] = this._viewportCoords.canvasPosition(pinch, element);
                let unprojected = this._viewportCoords.unprojectFromCanvas(canvasX, canvasY, element, render.perspective);
                let reference = transform.projectBasic(unprojected.toArray());
                const [canvasWidth, canvasHeight] = this._viewportCoords.containerToCanvas(element);
                let zoom = 3 * pinch.distanceChange / Math.min(canvasWidth, canvasHeight);
                this._navigator.stateService.zoomIn(zoom, reference);
            });
        }
        _disable() {
            this._activeSubscription.unsubscribe();
            this._preventDefaultSubscription.unsubscribe();
            this._zoomSubscription.unsubscribe();
            this._preventDefaultSubscription = null;
            this._zoomSubscription = null;
        }
        _getConfiguration(enable) {
            return { touchZoom: enable };
        }
    }

    /**
     * @class PointerComponent
     *
     * @classdesc Component handling mouse, pen, and touch events for camera movement.
     *
     * To retrive and use the mouse component
     *
     * @example
     * ```js
     * var viewer = new Viewer({ ... });
     *
     * var pointerComponent = viewer.getComponent("pointer");
     * ```
     */
    class PointerComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            const spatial = new Spatial();
            const viewportCoords = new ViewportCoords();
            this._bounceHandler =
                new BounceHandler(this, container, navigator, viewportCoords, spatial);
            this._dragPanHandler =
                new DragPanHandler(this, container, navigator, viewportCoords, spatial);
            this._earthControlHandler =
                new EarthControlHandler(this, container, navigator, viewportCoords, spatial);
            this._scrollZoomHandler =
                new ScrollZoomHandler(this, container, navigator, viewportCoords);
            this._touchZoomHandler =
                new TouchZoomHandler(this, container, navigator, viewportCoords);
        }
        /**
         * Get drag pan.
         *
         * @returns {DragPanHandler} The drag pan handler.
         */
        get dragPan() {
            return this._dragPanHandler;
        }
        /**
         * Get earth control.
         *
         * @returns {EarthControlHandler} The earth control handler.
         */
        get earthControl() {
            return this._earthControlHandler;
        }
        /**
         * Get scroll zoom.
         *
         * @returns {ScrollZoomHandler} The scroll zoom handler.
         */
        get scrollZoom() {
            return this._scrollZoomHandler;
        }
        /**
         * Get touch zoom.
         *
         * @returns {TouchZoomHandler} The touch zoom handler.
         */
        get touchZoom() {
            return this._touchZoomHandler;
        }
        _activate() {
            this._bounceHandler.enable();
            this._subscriptions.push(this._configuration$
                .subscribe((configuration) => {
                if (configuration.dragPan) {
                    this._dragPanHandler.enable();
                }
                else {
                    this._dragPanHandler.disable();
                }
                if (configuration.earthControl) {
                    this._earthControlHandler.enable();
                }
                else {
                    this._earthControlHandler.disable();
                }
                if (configuration.scrollZoom) {
                    this._scrollZoomHandler.enable();
                }
                else {
                    this._scrollZoomHandler.disable();
                }
                if (configuration.touchZoom) {
                    this._touchZoomHandler.enable();
                }
                else {
                    this._touchZoomHandler.disable();
                }
            }));
            this._container.mouseService.claimMouse(this._name, 0);
        }
        _deactivate() {
            this._container.mouseService.unclaimMouse(this._name);
            this._subscriptions.unsubscribe();
            this._bounceHandler.disable();
            this._dragPanHandler.disable();
            this._earthControlHandler.disable();
            this._scrollZoomHandler.disable();
            this._touchZoomHandler.disable();
        }
        _getDefaultConfiguration() {
            return {
                dragPan: true,
                earthControl: true,
                scrollZoom: true,
                touchZoom: true,
            };
        }
    }
    /** @inheritdoc */
    PointerComponent.componentName = "pointer";

    class DOM {
        constructor(doc) {
            this._document = !!doc ? doc : document;
        }
        get document() {
            return this._document;
        }
        createElement(tagName, className, container) {
            const element = this._document.createElement(tagName);
            if (!!className) {
                element.className = className;
            }
            if (!!container) {
                container.appendChild(element);
            }
            return element;
        }
    }

    /**
     * @class PopupComponent
     *
     * @classdesc Component for showing HTML popup objects.
     *
     * The `add` method is used for adding new popups. Popups are removed by reference.
     *
     * It is not possible to update popups in the set by updating any properties
     * directly on the popup object. Popups need to be replaced by
     * removing them and creating new ones with relevant changed properties and
     * adding those instead.
     *
     * Popups are only relevant to a single image because they are based on
     * 2D basic image coordinates. Popups related to a certain image should
     * be removed when the viewer is moved to another image.
     *
     * To retrive and use the popup component
     *
     * @example
     * ```js
     * var viewer = new Viewer({ component: { popup: true }, ... });
     *
     * var popupComponent = viewer.getComponent("popup");
     * ```
     */
    class PopupComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator, dom) {
            super(name, container, navigator);
            this._dom = !!dom ? dom : new DOM();
            this._popups = [];
            this._added$ = new Subject();
            this._popups$ = new Subject();
        }
        /**
         * Add popups to the popups set.
         *
         * @description Adding a new popup never replaces an old one
         * because they are stored by reference. Adding an already
         * existing popup has no effect.
         *
         * @param {Array<Popup>} popups - Popups to add.
         *
         * @example
         * ```js
         * popupComponent.add([popup1, popup2]);
         * ```
         */
        add(popups) {
            for (const popup of popups) {
                if (this._popups.indexOf(popup) !== -1) {
                    continue;
                }
                this._popups.push(popup);
                if (this._activated) {
                    popup.setParentContainer(this._popupContainer);
                }
            }
            this._added$.next(popups);
            this._popups$.next(this._popups);
        }
        /**
         * Returns an array of all popups.
         *
         * @example
         * ```js
         * var popups = popupComponent.getAll();
         * ```
         */
        getAll() {
            return this._popups.slice();
        }
        /**
         * Remove popups based on reference from the popup set.
         *
         * @param {Array<Popup>} popups - Popups to remove.
         *
         * @example
         * ```js
         * popupComponent.remove([popup1, popup2]);
         * ```
         */
        remove(popups) {
            for (const popup of popups) {
                this._remove(popup);
            }
            this._popups$.next(this._popups);
        }
        /**
         * Remove all popups from the popup set.
         *
         * @example
         * ```js
         * popupComponent.removeAll();
         * ```
         */
        removeAll() {
            for (const popup of this._popups.slice()) {
                this._remove(popup);
            }
            this._popups$.next(this._popups);
        }
        _activate() {
            this._popupContainer = this._dom.createElement("div", "mapillary-popup-container", this._container.container);
            for (const popup of this._popups) {
                popup.setParentContainer(this._popupContainer);
            }
            const subs = this._subscriptions;
            subs.push(combineLatest(this._container.renderService.renderCamera$, this._container.renderService.size$, this._navigator.stateService.currentTransform$)
                .subscribe(([renderCamera, size, transform]) => {
                for (const popup of this._popups) {
                    popup.update(renderCamera, size, transform);
                }
            }));
            const changed$ = this._popups$.pipe(startWith(this._popups), switchMap((popups) => {
                return from(popups).pipe(mergeMap((popup) => {
                    return popup.changed$;
                }));
            }), map((popup) => {
                return [popup];
            }));
            subs.push(merge(this._added$, changed$).pipe(withLatestFrom(this._container.renderService.renderCamera$, this._container.renderService.size$, this._navigator.stateService.currentTransform$))
                .subscribe(([popups, renderCamera, size, transform]) => {
                for (const popup of popups) {
                    popup.update(renderCamera, size, transform);
                }
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
            for (const popup of this._popups) {
                popup.remove();
            }
            this._container.container.removeChild(this._popupContainer);
            delete this._popupContainer;
        }
        _getDefaultConfiguration() {
            return {};
        }
        _remove(popup) {
            const index = this._popups.indexOf(popup);
            if (index === -1) {
                return;
            }
            const removed = this._popups.splice(index, 1)[0];
            if (this._activated) {
                removed.remove();
            }
        }
    }
    PopupComponent.componentName = "popup";

    /**
     * Enumeration for graph modes.
     * @enum {number}
     * @readonly
     * @description Modes for the retrieval and caching performed
     * by the graph service on the graph.
     */
    var GraphMode;
    (function (GraphMode) {
        /**
         * Caching is performed on sequences only and sequence edges are
         * calculated. Spatial tiles
         * are not retrieved and spatial edges are not calculated when
         * caching nodes. Complete sequences are being cached for requested
         * nodes within the graph.
         */
        GraphMode[GraphMode["Sequence"] = 0] = "Sequence";
        /**
         * Caching is performed with emphasis on spatial data. Sequence edges
         * as well as spatial edges are cached. Sequence data
         * is still requested but complete sequences are not being cached
         * for requested nodes.
         *
         * This is the initial mode of the graph service.
         */
        GraphMode[GraphMode["Spatial"] = 1] = "Spatial";
    })(GraphMode || (GraphMode = {}));

    var SequenceMode;
    (function (SequenceMode) {
        SequenceMode[SequenceMode["Default"] = 0] = "Default";
        SequenceMode[SequenceMode["Playback"] = 1] = "Playback";
        SequenceMode[SequenceMode["Timeline"] = 2] = "Timeline";
    })(SequenceMode || (SequenceMode = {}));

    class SequenceDOMRenderer {
        constructor(container) {
            this._container = container;
            this._minThresholdWidth = 320;
            this._maxThresholdWidth = 1480;
            this._minThresholdHeight = 240;
            this._maxThresholdHeight = 820;
            this._stepperDefaultWidth = 108;
            this._controlsDefaultWidth = 88;
            this._defaultHeight = 30;
            this._expandControls = false;
            this._mode = SequenceMode.Default;
            this._speed = 0.5;
            this._changingSpeed = false;
            this._index = null;
            this._changingPosition = false;
            this._mouseEnterDirection$ = new Subject();
            this._mouseLeaveDirection$ = new Subject();
            this._notifyChanged$ = new Subject();
            this._notifyChangingPositionChanged$ = new Subject();
            this._notifySpeedChanged$ = new Subject();
            this._notifyIndexChanged$ = new Subject();
        }
        get changed$() {
            return this._notifyChanged$;
        }
        get changingPositionChanged$() {
            return this._notifyChangingPositionChanged$;
        }
        get speed$() {
            return this._notifySpeedChanged$;
        }
        get index$() {
            return this._notifyIndexChanged$;
        }
        get mouseEnterDirection$() {
            return this._mouseEnterDirection$;
        }
        get mouseLeaveDirection$() {
            return this._mouseLeaveDirection$;
        }
        activate() {
            if (!!this._changingSubscription) {
                return;
            }
            this._changingSubscription = merge(this._container.mouseService.documentMouseUp$, this._container.touchService.touchEnd$.pipe(filter((touchEvent) => {
                return touchEvent.touches.length === 0;
            })))
                .subscribe(() => {
                if (this._changingSpeed) {
                    this._changingSpeed = false;
                }
                if (this._changingPosition) {
                    this._setChangingPosition(false);
                }
            });
        }
        deactivate() {
            if (!this._changingSubscription) {
                return;
            }
            this._changingSpeed = false;
            this._changingPosition = false;
            this._expandControls = false;
            this._mode = SequenceMode.Default;
            this._changingSubscription.unsubscribe();
            this._changingSubscription = null;
        }
        render(edgeStatus, configuration, containerWidth, speed, index, max, playEnabled, component, navigator) {
            if (configuration.visible === false) {
                return virtualDom.h("div.mapillary-sequence-container", {}, []);
            }
            const stepper = this._createStepper(edgeStatus, configuration, playEnabled, containerWidth, component, navigator);
            const controls = this._createSequenceControls(containerWidth);
            const playback = this._createPlaybackControls(containerWidth, speed, component, configuration);
            const timeline = this._createTimelineControls(containerWidth, index, max);
            return virtualDom.h("div.mapillary-sequence-container", [stepper, controls, playback, timeline]);
        }
        getContainerWidth(size, configuration) {
            let minWidth = configuration.minWidth;
            let maxWidth = configuration.maxWidth;
            if (maxWidth < minWidth) {
                maxWidth = minWidth;
            }
            let relativeWidth = (size.width - this._minThresholdWidth) / (this._maxThresholdWidth - this._minThresholdWidth);
            let relativeHeight = (size.height - this._minThresholdHeight) / (this._maxThresholdHeight - this._minThresholdHeight);
            let coeff = Math.max(0, Math.min(1, Math.min(relativeWidth, relativeHeight)));
            return minWidth + coeff * (maxWidth - minWidth);
        }
        _createPositionInput(index, max) {
            this._index = index;
            const onPosition = (e) => {
                this._index = Number(e.target.value);
                this._notifyIndexChanged$.next(this._index);
            };
            const boundingRect = this._container.domContainer.getBoundingClientRect();
            const width = Math.max(276, Math.min(410, 5 + 0.8 * boundingRect.width)) - 65;
            const onStart = (e) => {
                e.stopPropagation();
                this._setChangingPosition(true);
            };
            const onMove = (e) => {
                if (this._changingPosition === true) {
                    e.stopPropagation();
                }
            };
            const onKeyDown = (e) => {
                if (e.key === "ArrowDown" || e.key === "ArrowLeft" ||
                    e.key === "ArrowRight" || e.key === "ArrowUp") {
                    e.preventDefault();
                }
            };
            const positionInputProperties = {
                max: max != null ? max : 1,
                min: 0,
                onchange: onPosition,
                oninput: onPosition,
                onkeydown: onKeyDown,
                onpointerdown: onStart,
                onpointermove: onMove,
                ontouchmove: onMove,
                ontouchstart: onStart,
                style: {
                    width: `${width}px`,
                },
                type: "range",
                value: index != null ? index : 0,
            };
            const disabled = index == null || max == null || max <= 1;
            if (disabled) {
                positionInputProperties.disabled = "true";
            }
            const positionInput = virtualDom.h("input.mapillary-sequence-position", positionInputProperties, []);
            const positionContainerClass = disabled ? ".mapillary-sequence-position-container-inactive" : ".mapillary-sequence-position-container";
            return virtualDom.h("div" + positionContainerClass, [positionInput]);
        }
        _createSpeedInput(speed) {
            this._speed = speed;
            const onSpeed = (e) => {
                this._speed = Number(e.target.value) / 1000;
                this._notifySpeedChanged$.next(this._speed);
            };
            const boundingRect = this._container.domContainer.getBoundingClientRect();
            const width = Math.max(276, Math.min(410, 5 + 0.8 * boundingRect.width)) - 160;
            const onStart = (e) => {
                this._changingSpeed = true;
                e.stopPropagation();
            };
            const onMove = (e) => {
                if (this._changingSpeed === true) {
                    e.stopPropagation();
                }
            };
            const onKeyDown = (e) => {
                if (e.key === "ArrowDown" || e.key === "ArrowLeft" ||
                    e.key === "ArrowRight" || e.key === "ArrowUp") {
                    e.preventDefault();
                }
            };
            const speedInput = virtualDom.h("input.mapillary-sequence-speed", {
                max: 1000,
                min: 0,
                onchange: onSpeed,
                oninput: onSpeed,
                onkeydown: onKeyDown,
                onpointerdown: onStart,
                onpointermove: onMove,
                ontouchmove: onMove,
                ontouchstart: onStart,
                style: {
                    width: `${width}px`,
                },
                type: "range",
                value: 1000 * speed,
            }, []);
            return virtualDom.h("div.mapillary-sequence-speed-container", [speedInput]);
        }
        _createPlaybackControls(containerWidth, speed, component, configuration) {
            if (this._mode !== SequenceMode.Playback) {
                return virtualDom.h("div.mapillary-sequence-playback", []);
            }
            const switchIcon = virtualDom.h("div.mapillary-sequence-switch-icon.mapillary-sequence-icon-visible", []);
            const direction = configuration.direction === exports.NavigationDirection.Next ?
                exports.NavigationDirection.Prev : exports.NavigationDirection.Next;
            const playing = configuration.playing;
            const switchButtonProperties = {
                onclick: () => {
                    if (!playing) {
                        component.configure({ direction });
                    }
                },
            };
            const switchButtonClassName = configuration.playing ? ".mapillary-sequence-switch-button-inactive" : ".mapillary-sequence-switch-button";
            const switchButton = virtualDom.h("div" + switchButtonClassName, switchButtonProperties, [switchIcon]);
            const slowIcon = virtualDom.h("div.mapillary-sequence-slow-icon.mapillary-sequence-icon-visible", []);
            const slowContainer = virtualDom.h("div.mapillary-sequence-slow-container", [slowIcon]);
            const fastIcon = virtualDom.h("div.mapillary-sequence-fast-icon.mapillary-sequence-icon-visible", []);
            const fastContainer = virtualDom.h("div.mapillary-sequence-fast-container", [fastIcon]);
            const closeIcon = virtualDom.h("div.mapillary-sequence-close-icon.mapillary-sequence-icon-visible", []);
            const closeButtonProperties = {
                onclick: () => {
                    this._mode = SequenceMode.Default;
                    this._notifyChanged$.next(this);
                },
            };
            const closeButton = virtualDom.h("div.mapillary-sequence-close-button", closeButtonProperties, [closeIcon]);
            const speedInput = this._createSpeedInput(speed);
            const playbackChildren = [switchButton, slowContainer, speedInput, fastContainer, closeButton];
            const top = Math.round(containerWidth / this._stepperDefaultWidth * this._defaultHeight + 10);
            const playbackProperties = { style: { top: `${top}px` } };
            return virtualDom.h("div.mapillary-sequence-playback", playbackProperties, playbackChildren);
        }
        _createPlayingButton(nextId, prevId, playEnabled, configuration, component) {
            let canPlay = (configuration.direction === exports.NavigationDirection.Next && nextId != null) ||
                (configuration.direction === exports.NavigationDirection.Prev && prevId != null);
            canPlay = canPlay && playEnabled;
            let onclick = configuration.playing ?
                () => { component.stop(); } :
                canPlay ? () => { component.play(); } : null;
            let buttonProperties = { onclick: onclick };
            let iconProperties = {};
            if (configuration.direction === exports.NavigationDirection.Prev) {
                iconProperties.style = {
                    transform: "rotate(180deg) translate(50%, 50%)",
                };
            }
            let icon = virtualDom.h("div.mapillary-sequence-icon", iconProperties, []);
            let buttonClass = configuration.playing ?
                "mapillary-sequence-stop" :
                canPlay ?
                    "mapillary-sequence-play" :
                    "mapillary-sequence-play-inactive";
            return virtualDom.h("div." + buttonClass, buttonProperties, [icon]);
        }
        _createSequenceControls(containerWidth) {
            const borderRadius = Math.round(8 / this._stepperDefaultWidth * containerWidth);
            const expanderProperties = {
                onclick: () => {
                    this._expandControls = !this._expandControls;
                    this._mode = SequenceMode.Default;
                    this._notifyChanged$.next(this);
                },
                style: {
                    "border-bottom-right-radius": `${borderRadius}px`,
                    "border-top-right-radius": `${borderRadius}px`,
                },
            };
            const expanderBar = virtualDom.h("div.mapillary-sequence-expander-bar", []);
            const expander = virtualDom.h("div.mapillary-sequence-expander-button", expanderProperties, [expanderBar]);
            const fastIconClassName = this._mode === SequenceMode.Playback ?
                ".mapillary-sequence-fast-icon-gray.mapillary-sequence-icon-visible" : ".mapillary-sequence-fast-icon";
            const fastIcon = virtualDom.h("div" + fastIconClassName, []);
            const playbackProperties = {
                onclick: () => {
                    this._mode = this._mode === SequenceMode.Playback ?
                        SequenceMode.Default :
                        SequenceMode.Playback;
                    this._notifyChanged$.next(this);
                },
            };
            const playback = virtualDom.h("div.mapillary-sequence-playback-button", playbackProperties, [fastIcon]);
            const timelineIconClassName = this._mode === SequenceMode.Timeline ?
                ".mapillary-sequence-timeline-icon-gray.mapillary-sequence-icon-visible" : ".mapillary-sequence-timeline-icon";
            const timelineIcon = virtualDom.h("div" + timelineIconClassName, []);
            const timelineProperties = {
                onclick: () => {
                    this._mode = this._mode === SequenceMode.Timeline ?
                        SequenceMode.Default :
                        SequenceMode.Timeline;
                    this._notifyChanged$.next(this);
                },
            };
            const timeline = virtualDom.h("div.mapillary-sequence-timeline-button", timelineProperties, [timelineIcon]);
            const properties = {
                style: {
                    height: (this._defaultHeight / this._stepperDefaultWidth * containerWidth) + "px",
                    transform: `translate(${containerWidth / 2 + 2}px, 0)`,
                    width: (this._controlsDefaultWidth / this._stepperDefaultWidth * containerWidth) + "px",
                },
            };
            const className = ".mapillary-sequence-controls" +
                (this._expandControls ? ".mapillary-sequence-controls-expanded" : "");
            return virtualDom.h("div" + className, properties, [playback, timeline, expander]);
        }
        _createSequenceArrows(nextId, prevId, containerWidth, configuration, navigator) {
            let nextProperties = {
                onclick: nextId != null ?
                    () => {
                        navigator.moveDir$(exports.NavigationDirection.Next)
                            .subscribe(undefined, (error) => {
                            if (!(error instanceof CancelMapillaryError)) {
                                console.error(error);
                            }
                        });
                    } :
                    null,
                onpointerenter: () => { this._mouseEnterDirection$.next(exports.NavigationDirection.Next); },
                onpointerleave: () => { this._mouseLeaveDirection$.next(exports.NavigationDirection.Next); },
            };
            const borderRadius = Math.round(8 / this._stepperDefaultWidth * containerWidth);
            let prevProperties = {
                onclick: prevId != null ?
                    () => {
                        navigator.moveDir$(exports.NavigationDirection.Prev)
                            .subscribe(undefined, (error) => {
                            if (!(error instanceof CancelMapillaryError)) {
                                console.error(error);
                            }
                        });
                    } :
                    null,
                onpointerenter: () => { this._mouseEnterDirection$.next(exports.NavigationDirection.Prev); },
                onpointerleave: () => { this._mouseLeaveDirection$.next(exports.NavigationDirection.Prev); },
                style: {
                    "border-bottom-left-radius": `${borderRadius}px`,
                    "border-top-left-radius": `${borderRadius}px`,
                },
            };
            let nextClass = this._getStepClassName(exports.NavigationDirection.Next, nextId, configuration.highlightId);
            let prevClass = this._getStepClassName(exports.NavigationDirection.Prev, prevId, configuration.highlightId);
            let nextIcon = virtualDom.h("div.mapillary-sequence-icon", []);
            let prevIcon = virtualDom.h("div.mapillary-sequence-icon", []);
            return [
                virtualDom.h("div." + prevClass, prevProperties, [prevIcon]),
                virtualDom.h("div." + nextClass, nextProperties, [nextIcon]),
            ];
        }
        _createStepper(edgeStatus, configuration, playEnabled, containerWidth, component, navigator) {
            let nextId = null;
            let prevId = null;
            for (let edge of edgeStatus.edges) {
                if (edge.data.direction === exports.NavigationDirection.Next) {
                    nextId = edge.target;
                }
                if (edge.data.direction === exports.NavigationDirection.Prev) {
                    prevId = edge.target;
                }
            }
            const playingButton = this._createPlayingButton(nextId, prevId, playEnabled, configuration, component);
            const buttons = this._createSequenceArrows(nextId, prevId, containerWidth, configuration, navigator);
            buttons.splice(1, 0, playingButton);
            const containerProperties = {
                oncontextmenu: (event) => { event.preventDefault(); },
                style: {
                    height: (this._defaultHeight / this._stepperDefaultWidth * containerWidth) + "px",
                    width: containerWidth + "px",
                },
            };
            return virtualDom.h("div.mapillary-sequence-stepper", containerProperties, buttons);
        }
        _createTimelineControls(containerWidth, index, max) {
            if (this._mode !== SequenceMode.Timeline) {
                return virtualDom.h("div.mapillary-sequence-timeline", []);
            }
            const positionInput = this._createPositionInput(index, max);
            const closeIcon = virtualDom.h("div.mapillary-sequence-close-icon.mapillary-sequence-icon-visible", []);
            const closeButtonProperties = {
                onclick: () => {
                    this._mode = SequenceMode.Default;
                    this._notifyChanged$.next(this);
                },
            };
            const closeButton = virtualDom.h("div.mapillary-sequence-close-button", closeButtonProperties, [closeIcon]);
            const top = Math.round(containerWidth / this._stepperDefaultWidth * this._defaultHeight + 10);
            const playbackProperties = { style: { top: `${top}px` } };
            return virtualDom.h("div.mapillary-sequence-timeline", playbackProperties, [positionInput, closeButton]);
        }
        _getStepClassName(direction, imageId, highlightId) {
            let className = direction === exports.NavigationDirection.Next ?
                "mapillary-sequence-step-next" :
                "mapillary-sequence-step-prev";
            if (imageId == null) {
                className += "-inactive";
            }
            else {
                if (highlightId === imageId) {
                    className += "-highlight";
                }
            }
            return className;
        }
        _setChangingPosition(value) {
            this._changingPosition = value;
            this._notifyChangingPositionChanged$.next(value);
        }
    }

    /**
     * @class SequenceComponent
     * @classdesc Component showing navigation arrows for sequence directions
     * as well as playing button. Exposes an API to start and stop play.
     */
    class SequenceComponent extends Component {
        constructor(name, container, navigator, renderer, scheduler) {
            super(name, container, navigator);
            this._sequenceDOMRenderer = !!renderer ? renderer : new SequenceDOMRenderer(container);
            this._scheduler = scheduler;
            this._containerWidth$ = new Subject();
            this._hoveredIdSubject$ = new Subject();
            this._hoveredId$ = this._hoveredIdSubject$.pipe(share());
            this._navigator.playService.playing$.pipe(skip(1), withLatestFrom(this._configuration$))
                .subscribe(([playing, configuration]) => {
                const type = "playing";
                const event = {
                    playing,
                    target: this,
                    type,
                };
                this.fire(type, event);
                if (playing === configuration.playing) {
                    return;
                }
                if (playing) {
                    this.play();
                }
                else {
                    this.stop();
                }
            });
            this._navigator.playService.direction$.pipe(skip(1), withLatestFrom(this._configuration$))
                .subscribe(([direction, configuration]) => {
                if (direction !== configuration.direction) {
                    this.configure({ direction });
                }
            });
        }
        fire(type, event) {
            super.fire(type, event);
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Start playing.
         *
         * @fires playing
         */
        play() { this.configure({ playing: true }); }
        /**
         * Stop playing.
         *
         * @fires playing
         */
        stop() { this.configure({ playing: false }); }
        _activate() {
            this._sequenceDOMRenderer.activate();
            const edgeStatus$ = this._navigator.stateService.currentImage$.pipe(switchMap((image) => {
                return image.sequenceEdges$;
            }), publishReplay(1), refCount());
            const sequence$ = this._navigator.stateService.currentImage$.pipe(distinctUntilChanged(undefined, (image) => {
                return image.sequenceId;
            }), switchMap((image) => {
                return concat(of(null), this._navigator.graphService.cacheSequence$(image.sequenceId).pipe(retry(3), catchError((e) => {
                    console.error("Failed to cache sequence", e);
                    return of(null);
                })));
            }), startWith(null), publishReplay(1), refCount());
            const subs = this._subscriptions;
            subs.push(sequence$.subscribe());
            const rendererId$ = this._sequenceDOMRenderer.index$.pipe(withLatestFrom(sequence$), map(([index, sequence]) => {
                return sequence != null ? sequence.imageIds[index] : null;
            }), filter((id) => {
                return !!id;
            }), distinctUntilChanged(), publish(), refCount());
            subs.push(merge(rendererId$.pipe(debounceTime(100, this._scheduler)), rendererId$.pipe(auditTime(400, this._scheduler))).pipe(distinctUntilChanged(), switchMap((id) => {
                return this._navigator.moveTo$(id).pipe(catchError(() => {
                    return empty();
                }));
            }))
                .subscribe());
            subs.push(this._sequenceDOMRenderer.changingPositionChanged$.pipe(filter((changing) => {
                return changing;
            }))
                .subscribe(() => {
                this._navigator.graphService.setGraphMode(GraphMode.Sequence);
            }));
            subs.push(this._sequenceDOMRenderer.changingPositionChanged$.pipe(filter((changing) => {
                return !changing;
            }))
                .subscribe(() => {
                this._navigator.graphService.setGraphMode(GraphMode.Spatial);
            }));
            this._navigator.graphService.graphMode$.pipe(switchMap((mode) => {
                return mode === GraphMode.Spatial ?
                    this._navigator.stateService.currentImage$.pipe(take(2)) :
                    empty();
            }), filter((image) => {
                return !image.spatialEdges.cached;
            }), switchMap((image) => {
                return this._navigator.graphService.cacheImage$(image.id).pipe(catchError(() => {
                    return empty();
                }));
            }))
                .subscribe();
            subs.push(this._sequenceDOMRenderer.changingPositionChanged$.pipe(filter((changing) => {
                return changing;
            }))
                .subscribe(() => {
                this._navigator.playService.stop();
            }));
            subs.push(combineLatest(this._navigator.graphService.graphMode$, this._sequenceDOMRenderer.changingPositionChanged$.pipe(startWith(false), distinctUntilChanged())).pipe(withLatestFrom(this._navigator.stateService.currentImage$), switchMap(([[mode, changing], image]) => {
                return changing && mode === GraphMode.Sequence ?
                    this._navigator.graphService.cacheSequenceImages$(image.sequenceId, image.id).pipe(retry(3), catchError((error) => {
                        console.error("Failed to cache sequence images.", error);
                        return empty();
                    })) :
                    empty();
            }))
                .subscribe());
            const position$ = sequence$.pipe(switchMap((sequence) => {
                if (!sequence) {
                    return of({ index: null, max: null });
                }
                let firstCurrentId = true;
                return this._sequenceDOMRenderer.changingPositionChanged$.pipe(startWith(false), distinctUntilChanged(), switchMap((changingPosition) => {
                    const skipCount = !changingPosition &&
                        firstCurrentId ?
                        0 : 1;
                    firstCurrentId = false;
                    return changingPosition ?
                        rendererId$ :
                        this._navigator.stateService.currentImage$.pipe(map((image) => {
                            return image.id;
                        }), distinctUntilChanged(), skip(skipCount));
                }), map((imageId) => {
                    const index = sequence.imageIds.indexOf(imageId);
                    if (index === -1) {
                        return { index: null, max: null };
                    }
                    return { index: index, max: sequence.imageIds.length - 1 };
                }));
            }));
            const earth$ = this._navigator.stateService.state$.pipe(map((state) => {
                return state === State.Earth;
            }), distinctUntilChanged());
            subs.push(combineLatest(edgeStatus$, this._configuration$, this._containerWidth$, this._sequenceDOMRenderer.changed$.pipe(startWith(this._sequenceDOMRenderer)), this._navigator.playService.speed$, position$, earth$).pipe(map(([edgeStatus, configuration, containerWidth, , speed, position, earth]) => {
                const vNode = this._sequenceDOMRenderer
                    .render(edgeStatus, configuration, containerWidth, speed, position.index, position.max, !earth, this, this._navigator);
                return { name: this._name, vNode: vNode };
            }))
                .subscribe(this._container.domRenderer.render$));
            subs.push(this._sequenceDOMRenderer.speed$
                .subscribe((speed) => {
                this._navigator.playService.setSpeed(speed);
            }));
            subs.push(this._configuration$.pipe(map((configuration) => {
                return configuration.direction;
            }), distinctUntilChanged())
                .subscribe((direction) => {
                this._navigator.playService.setDirection(direction);
            }));
            subs.push(combineLatest(this._container.renderService.size$, this._configuration$.pipe(distinctUntilChanged((value1, value2) => {
                return value1[0] === value2[0] && value1[1] === value2[1];
            }, (configuration) => {
                return [configuration.minWidth, configuration.maxWidth];
            }))).pipe(map(([size, configuration]) => {
                return this._sequenceDOMRenderer.getContainerWidth(size, configuration);
            }))
                .subscribe(this._containerWidth$));
            subs.push(this._configuration$.pipe(map((configuration) => {
                return configuration.playing;
            }), distinctUntilChanged())
                .subscribe((playing) => {
                if (playing) {
                    this._navigator.playService.play();
                }
                else {
                    this._navigator.playService.stop();
                }
            }));
            subs.push(this._sequenceDOMRenderer.mouseEnterDirection$.pipe(switchMap((direction) => {
                const edgeTo$ = edgeStatus$.pipe(map((edgeStatus) => {
                    for (let edge of edgeStatus.edges) {
                        if (edge.data.direction === direction) {
                            return edge.target;
                        }
                    }
                    return null;
                }), takeUntil(this._sequenceDOMRenderer.mouseLeaveDirection$));
                return concat(edgeTo$, of(null));
            }), distinctUntilChanged())
                .subscribe(this._hoveredIdSubject$));
            subs.push(this._hoveredId$
                .subscribe((id) => {
                const type = "hover";
                const event = {
                    id,
                    target: this,
                    type,
                };
                this.fire(type, event);
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
            this._sequenceDOMRenderer.deactivate();
        }
        _getDefaultConfiguration() {
            return {
                direction: exports.NavigationDirection.Next,
                maxWidth: 108,
                minWidth: 70,
                playing: false,
                visible: true,
            };
        }
    }
    /** @inheritdoc */
    SequenceComponent.componentName = "sequence";

    /**
     * Enumeration for slider mode.
     *
     * @enum {number}
     * @readonly
     *
     * @description Modes for specifying how transitions
     * between images are performed in slider mode. Only
     * applicable when the slider component determines
     * that transitions with motion is possilble. When it
     * is not, the stationary mode will be applied.
     */
    exports.SliderConfigurationMode = void 0;
    (function (SliderConfigurationMode) {
        /**
         * Transitions with motion.
         *
         * @description The slider component moves the
         * camera between the image origins.
         *
         * In this mode it is not possible to zoom or pan.
         *
         * The slider component falls back to stationary
         * mode when it determines that the pair of images
         * does not have a strong enough relation.
         */
        SliderConfigurationMode[SliderConfigurationMode["Motion"] = 0] = "Motion";
        /**
         * Stationary transitions.
         *
         * @description The camera is stationary.
         *
         * In this mode it is possible to zoom and pan.
         */
        SliderConfigurationMode[SliderConfigurationMode["Stationary"] = 1] = "Stationary";
    })(exports.SliderConfigurationMode || (exports.SliderConfigurationMode = {}));

    class SliderGLRenderer {
        constructor() {
            this._factory = new MeshFactory();
            this._scene = new MeshScene();
            this._spatial = new Spatial();
            this._currentKey = null;
            this._previousKey = null;
            this._disabled = false;
            this._curtain = 1;
            this._frameId = 0;
            this._needsRender = false;
            this._mode = null;
            this._currentProviderDisposers = {};
            this._previousProviderDisposers = {};
        }
        get disabled() {
            return this._disabled;
        }
        get frameId() {
            return this._frameId;
        }
        get needsRender() {
            return this._needsRender;
        }
        setTextureProvider(key, provider) {
            this._setTextureProvider(key, this._currentKey, provider, this._currentProviderDisposers, this._updateTexture.bind(this));
        }
        setTextureProviderPrev(key, provider) {
            this._setTextureProvider(key, this._previousKey, provider, this._previousProviderDisposers, this._updateTexturePrev.bind(this));
        }
        update(frame, mode) {
            this._updateFrameId(frame.id);
            this._updateImagePlanes(frame.state, mode);
        }
        updateCurtain(curtain) {
            if (this._curtain === curtain) {
                return;
            }
            this._curtain = curtain;
            this._updateCurtain();
            this._needsRender = true;
        }
        updateTexture(imageElement, image) {
            const planes = image.id === this._currentKey ?
                this._scene.planes :
                image.id === this._previousKey ?
                    this._scene.planesOld :
                    {};
            if (Object.keys(planes).length === 0) {
                return;
            }
            this._needsRender = true;
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                let material = plane.material;
                let texture = material.uniforms.projectorTex.value;
                texture.image = imageElement;
                texture.needsUpdate = true;
            }
        }
        updateTextureImage(imageElement, image) {
            if (this._currentKey !== image.id) {
                return;
            }
            this._needsRender = true;
            const planes = this._scene.planes;
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                let material = plane.material;
                let texture = material.uniforms.projectorTex.value;
                texture.image = imageElement;
                texture.needsUpdate = true;
            }
        }
        render(perspectiveCamera, renderer) {
            if (!this.disabled) {
                renderer.render(this._scene.sceneOld, perspectiveCamera);
            }
            renderer.render(this._scene.scene, perspectiveCamera);
            this._needsRender = false;
        }
        dispose() {
            this._scene.clear();
            for (const key in this._currentProviderDisposers) {
                if (!this._currentProviderDisposers.hasOwnProperty(key)) {
                    continue;
                }
                this._currentProviderDisposers[key]();
            }
            for (const key in this._previousProviderDisposers) {
                if (!this._previousProviderDisposers.hasOwnProperty(key)) {
                    continue;
                }
                this._previousProviderDisposers[key]();
            }
            this._currentProviderDisposers = {};
            this._previousProviderDisposers = {};
        }
        _getBasicCorners(currentAspect, previousAspect) {
            let offsetX;
            let offsetY;
            if (currentAspect > previousAspect) {
                offsetX = 0.5;
                offsetY = 0.5 * currentAspect / previousAspect;
            }
            else {
                offsetX = 0.5 * previousAspect / currentAspect;
                offsetY = 0.5;
            }
            return [[0.5 - offsetX, 0.5 - offsetY], [0.5 + offsetX, 0.5 + offsetY]];
        }
        _setDisabled(state) {
            this._disabled = state.currentImage == null ||
                state.previousImage == null ||
                (isSpherical(state.currentImage.cameraType) &&
                    !isSpherical(state.previousImage.cameraType));
        }
        _setTextureProvider(key, originalKey, provider, providerDisposers, updateTexture) {
            if (key !== originalKey) {
                return;
            }
            let createdSubscription = provider.textureCreated$
                .subscribe(updateTexture);
            let updatedSubscription = provider.textureUpdated$
                .subscribe((updated) => {
                this._needsRender = true;
            });
            let dispose = () => {
                createdSubscription.unsubscribe();
                updatedSubscription.unsubscribe();
                provider.dispose();
            };
            if (key in providerDisposers) {
                let disposeProvider = providerDisposers[key];
                disposeProvider();
                delete providerDisposers[key];
            }
            providerDisposers[key] = dispose;
        }
        _updateCurtain() {
            const planes = this._scene.planes;
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                let shaderMaterial = plane.material;
                if (!!shaderMaterial.uniforms.curtain) {
                    shaderMaterial.uniforms.curtain.value = this._curtain;
                }
            }
        }
        _updateFrameId(frameId) {
            this._frameId = frameId;
        }
        _updateImagePlanes(state, mode) {
            const currentChanged = state.currentImage != null && this._currentKey !== state.currentImage.id;
            const previousChanged = state.previousImage != null && this._previousKey !== state.previousImage.id;
            const modeChanged = this._mode !== mode;
            if (!(currentChanged || previousChanged || modeChanged)) {
                return;
            }
            this._setDisabled(state);
            this._needsRender = true;
            this._mode = mode;
            const motionless = state.motionless ||
                mode === exports.SliderConfigurationMode.Stationary ||
                isSpherical(state.currentImage.cameraType);
            if (this.disabled || previousChanged) {
                if (this._previousKey in this._previousProviderDisposers) {
                    this._previousProviderDisposers[this._previousKey]();
                    delete this._previousProviderDisposers[this._previousKey];
                }
            }
            if (this.disabled) {
                this._scene.setImagePlanesOld({});
            }
            else {
                if (previousChanged || modeChanged) {
                    const previousNode = state.previousImage;
                    this._previousKey = previousNode.id;
                    const elements = state.currentTransform.rt.elements;
                    let translation = [elements[12], elements[13], elements[14]];
                    const currentAspect = state.currentTransform.basicAspect;
                    const previousAspect = state.previousTransform.basicAspect;
                    const textureScale = currentAspect > previousAspect ?
                        [1, previousAspect / currentAspect] :
                        [currentAspect / previousAspect, 1];
                    let rotation = state.currentImage.rotation;
                    let width = state.currentImage.width;
                    let height = state.currentImage.height;
                    if (isSpherical(previousNode.cameraType)) {
                        rotation = state.previousImage.rotation;
                        translation = this._spatial
                            .rotate(this._spatial
                            .opticalCenter(state.currentImage.rotation, translation)
                            .toArray(), rotation)
                            .multiplyScalar(-1)
                            .toArray();
                        width = state.previousImage.width;
                        height = state.previousImage.height;
                    }
                    const transform = new Transform(state.currentImage.exifOrientation, width, height, state.currentImage.scale, rotation, translation, previousNode.image, textureScale, state.currentImage.cameraParameters, state.currentImage.cameraType);
                    let mesh = undefined;
                    if (isSpherical(previousNode.cameraType)) {
                        mesh = this._factory.createMesh(previousNode, motionless ||
                            isSpherical(state.currentImage.cameraType) ?
                            transform : state.previousTransform);
                    }
                    else {
                        if (motionless) {
                            const [[basicX0, basicY0], [basicX1, basicY1]] = this._getBasicCorners(currentAspect, previousAspect);
                            mesh = this._factory.createFlatMesh(state.previousImage, transform, basicX0, basicX1, basicY0, basicY1);
                        }
                        else {
                            mesh = this._factory.createMesh(state.previousImage, state.previousTransform);
                        }
                    }
                    const previousPlanes = {};
                    previousPlanes[previousNode.id] = mesh;
                    this._scene.setImagePlanesOld(previousPlanes);
                }
            }
            if (currentChanged || modeChanged) {
                if (this._currentKey in this._currentProviderDisposers) {
                    this._currentProviderDisposers[this._currentKey]();
                    delete this._currentProviderDisposers[this._currentKey];
                }
                this._currentKey = state.currentImage.id;
                const planes = {};
                if (isSpherical(state.currentImage.cameraType)) {
                    planes[state.currentImage.id] =
                        this._factory.createCurtainMesh(state.currentImage, state.currentTransform);
                }
                else {
                    if (motionless) {
                        planes[state.currentImage.id] = this._factory.createDistortedCurtainMesh(state.currentImage, state.currentTransform);
                    }
                    else {
                        planes[state.currentImage.id] = this._factory.createCurtainMesh(state.currentImage, state.currentTransform);
                    }
                }
                this._scene.setImagePlanes(planes);
                this._updateCurtain();
            }
        }
        _updateTexture(texture) {
            this._needsRender = true;
            const planes = this._scene.planes;
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                let material = plane.material;
                let oldTexture = material.uniforms.projectorTex.value;
                material.uniforms.projectorTex.value = null;
                oldTexture.dispose();
                material.uniforms.projectorTex.value = texture;
            }
        }
        _updateTexturePrev(texture) {
            this._needsRender = true;
            const planes = this._scene.planesOld;
            for (const key in planes) {
                if (!planes.hasOwnProperty(key)) {
                    continue;
                }
                const plane = planes[key];
                let material = plane.material;
                let oldTexture = material.uniforms.projectorTex.value;
                material.uniforms.projectorTex.value = null;
                oldTexture.dispose();
                material.uniforms.projectorTex.value = texture;
            }
        }
    }

    class SliderDOMRenderer {
        constructor(container) {
            this._container = container;
            this._interacting = false;
            this._notifyModeChanged$ = new Subject();
            this._notifyPositionChanged$ = new Subject();
            this._stopInteractionSubscription = null;
        }
        get mode$() {
            return this._notifyModeChanged$;
        }
        get position$() {
            return this._notifyPositionChanged$;
        }
        activate() {
            if (!!this._stopInteractionSubscription) {
                return;
            }
            this._stopInteractionSubscription = merge(this._container.mouseService.documentMouseUp$, this._container.touchService.touchEnd$.pipe(filter((touchEvent) => {
                return touchEvent.touches.length === 0;
            })))
                .subscribe((event) => {
                if (this._interacting) {
                    this._interacting = false;
                }
            });
        }
        deactivate() {
            if (!this._stopInteractionSubscription) {
                return;
            }
            this._interacting = false;
            this._stopInteractionSubscription.unsubscribe();
            this._stopInteractionSubscription = null;
        }
        render(position, mode, motionless, spherical, visible) {
            const children = [];
            if (visible) {
                children.push(virtualDom.h("div.mapillary-slider-border", []));
                const modeVisible = !(motionless || spherical);
                if (modeVisible) {
                    children.push(this._createModeButton(mode));
                    children.push(this._createModeButton2d(mode));
                }
                children.push(this._createPositionInput(position, modeVisible));
            }
            const boundingRect = this._container.domContainer.getBoundingClientRect();
            const width = Math.max(215, Math.min(400, boundingRect.width - 100));
            return virtualDom.h("div.mapillary-slider-container", { style: { width: `${width}px` } }, children);
        }
        _createModeButton(mode) {
            const properties = {
                onclick: () => {
                    if (mode === exports.SliderConfigurationMode.Motion) {
                        return;
                    }
                    this._notifyModeChanged$.next(exports.SliderConfigurationMode.Motion);
                },
            };
            const className = mode === exports.SliderConfigurationMode.Stationary ?
                "mapillary-slider-mode-button-inactive" :
                "mapillary-slider-mode-button";
            return virtualDom.h("div." + className, properties, [virtualDom.h("div.mapillary-slider-mode-icon", [])]);
        }
        _createModeButton2d(mode) {
            const properties = {
                onclick: () => {
                    if (mode === exports.SliderConfigurationMode.Stationary) {
                        return;
                    }
                    this._notifyModeChanged$.next(exports.SliderConfigurationMode.Stationary);
                },
            };
            const className = mode === exports.SliderConfigurationMode.Motion ?
                "mapillary-slider-mode-button-2d-inactive" :
                "mapillary-slider-mode-button-2d";
            return virtualDom.h("div." + className, properties, [virtualDom.h("div.mapillary-slider-mode-icon-2d", [])]);
        }
        _createPositionInput(position, modeVisible) {
            const onChange = (e) => {
                this._notifyPositionChanged$.next(Number(e.target.value) / 1000);
            };
            const onStart = (e) => {
                this._interacting = true;
                e.stopPropagation();
            };
            const onMove = (e) => {
                if (this._interacting) {
                    e.stopPropagation();
                }
            };
            const onKeyDown = (e) => {
                if (e.key === "ArrowDown" || e.key === "ArrowLeft" ||
                    e.key === "ArrowRight" || e.key === "ArrowUp") {
                    e.preventDefault();
                }
            };
            const boundingRect = this._container.domContainer.getBoundingClientRect();
            const width = Math.max(215, Math.min(400, boundingRect.width - 105)) - 84 + (modeVisible ? 0 : 52);
            const positionInput = virtualDom.h("input.mapillary-slider-position", {
                max: 1000,
                min: 0,
                onchange: onChange,
                oninput: onChange,
                onkeydown: onKeyDown,
                onpointerdown: onStart,
                onpointermove: onMove,
                ontouchmove: onMove,
                ontouchstart: onStart,
                style: {
                    width: `${width}px`,
                },
                type: "range",
                value: 1000 * position,
            }, []);
            return virtualDom.h("div.mapillary-slider-position-container", [positionInput]);
        }
    }

    /**
     * @class SliderComponent
     *
     * @classdesc Component for comparing pairs of images. Renders
     * a slider for adjusting the curtain of the first image.
     *
     * Deactivate the sequence, direction and image plane
     * components when activating the slider component to avoid
     * interfering UI elements.
     *
     * To retrive and use the slider component
     *
     * @example
     * ```js
     * var viewer = new Viewer({ ... });
     *
     * viewer.deactivateComponent("image");
     * viewer.deactivateComponent("direction");
     * viewer.deactivateComponent("sequence");
     *
     * viewer.activateComponent("slider");
     *
     * var sliderComponent = viewer.getComponent("slider");
     * ```
     */
    class SliderComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator, viewportCoords) {
            super(name, container, navigator);
            this._viewportCoords = !!viewportCoords ? viewportCoords : new ViewportCoords();
            this._domRenderer = new SliderDOMRenderer(container);
            this._imageTileLoader = new TileLoader(navigator.api);
            this._roiCalculator = new RegionOfInterestCalculator();
            this._spatial = new Spatial();
            this._glRendererOperation$ = new Subject();
            this._glRendererCreator$ = new Subject();
            this._glRendererDisposer$ = new Subject();
            this._glRenderer$ = this._glRendererOperation$.pipe(scan((glRenderer, operation) => {
                return operation(glRenderer);
            }, null), filter((glRenderer) => {
                return glRenderer != null;
            }), distinctUntilChanged(undefined, (glRenderer) => {
                return glRenderer.frameId;
            }));
            this._glRendererCreator$.pipe(map(() => {
                return (glRenderer) => {
                    if (glRenderer != null) {
                        throw new Error("Multiple slider states can not be created at the same time");
                    }
                    return new SliderGLRenderer();
                };
            }))
                .subscribe(this._glRendererOperation$);
            this._glRendererDisposer$.pipe(map(() => {
                return (glRenderer) => {
                    glRenderer.dispose();
                    return null;
                };
            }))
                .subscribe(this._glRendererOperation$);
        }
        _activate() {
            const subs = this._subscriptions;
            subs.push(this._domRenderer.mode$
                .subscribe((mode) => {
                this.configure({ mode });
            }));
            subs.push(this._glRenderer$.pipe(map((glRenderer) => {
                let renderHash = {
                    name: this._name,
                    renderer: {
                        frameId: glRenderer.frameId,
                        needsRender: glRenderer.needsRender,
                        render: glRenderer.render.bind(glRenderer),
                        pass: RenderPass.Background,
                    },
                };
                return renderHash;
            }))
                .subscribe(this._container.glRenderer.render$));
            const position$ = concat(this.configuration$.pipe(map((configuration) => {
                return configuration.initialPosition != null ?
                    configuration.initialPosition : 1;
            }), first()), this._domRenderer.position$);
            const mode$ = this.configuration$.pipe(map((configuration) => {
                return configuration.mode;
            }), distinctUntilChanged());
            const motionless$ = this._navigator.stateService.currentState$.pipe(map((frame) => {
                return frame.state.motionless;
            }), distinctUntilChanged());
            const spherical$ = this._navigator.stateService.currentState$.pipe(map((frame) => {
                return isSpherical(frame.state.currentImage.cameraType);
            }), distinctUntilChanged());
            const sliderVisible$ = combineLatest(this._configuration$.pipe(map((configuration) => {
                return configuration.sliderVisible;
            })), this._navigator.stateService.currentState$.pipe(map((frame) => {
                return !(frame.state.currentImage == null ||
                    frame.state.previousImage == null ||
                    (isSpherical(frame.state.currentImage.cameraType) &&
                        !isSpherical(frame.state.previousImage.cameraType)));
            }), distinctUntilChanged())).pipe(map(([sliderVisible, enabledState]) => {
                return sliderVisible && enabledState;
            }), distinctUntilChanged());
            this._waitSubscription = combineLatest(mode$, motionless$, spherical$, sliderVisible$).pipe(withLatestFrom(this._navigator.stateService.state$))
                .subscribe(([[mode, motionless, spherical, sliderVisible], state]) => {
                const interactive = sliderVisible &&
                    (motionless ||
                        mode === exports.SliderConfigurationMode.Stationary ||
                        spherical);
                if (interactive && state !== State.WaitingInteractively) {
                    this._navigator.stateService.waitInteractively();
                }
                else if (!interactive && state !== State.Waiting) {
                    this._navigator.stateService.wait();
                }
            });
            subs.push(combineLatest(position$, mode$, motionless$, spherical$, sliderVisible$)
                .subscribe(([position, mode, motionless, spherical]) => {
                if (motionless || mode === exports.SliderConfigurationMode.Stationary || spherical) {
                    this._navigator.stateService.moveTo(1);
                }
                else {
                    this._navigator.stateService.moveTo(position);
                }
            }));
            subs.push(combineLatest(position$, mode$, motionless$, spherical$, sliderVisible$, this._container.renderService.size$).pipe(map(([position, mode, motionless, spherical, sliderVisible]) => {
                return {
                    name: this._name,
                    vNode: this._domRenderer.render(position, mode, motionless, spherical, sliderVisible),
                };
            }))
                .subscribe(this._container.domRenderer.render$));
            this._glRendererCreator$.next(null);
            subs.push(combineLatest(position$, spherical$, sliderVisible$, this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$).pipe(map(([position, spherical, visible, render, transform]) => {
                if (!spherical) {
                    return visible ? position : 1;
                }
                const basicMin = this._viewportCoords.viewportToBasic(-1.15, 0, transform, render.perspective);
                const basicMax = this._viewportCoords.viewportToBasic(1.15, 0, transform, render.perspective);
                const shiftedMax = basicMax[0] < basicMin[0] ? basicMax[0] + 1 : basicMax[0];
                const basicPosition = basicMin[0] + position * (shiftedMax - basicMin[0]);
                return basicPosition > 1 ? basicPosition - 1 : basicPosition;
            }), map((position) => {
                return (glRenderer) => {
                    glRenderer.updateCurtain(position);
                    return glRenderer;
                };
            }))
                .subscribe(this._glRendererOperation$));
            subs.push(combineLatest(this._navigator.stateService.currentState$, mode$).pipe(map(([frame, mode]) => {
                return (glRenderer) => {
                    glRenderer.update(frame, mode);
                    return glRenderer;
                };
            }))
                .subscribe(this._glRendererOperation$));
            subs.push(this._configuration$.pipe(filter((configuration) => {
                return configuration.ids != null;
            }), switchMap((configuration) => {
                return zip(zip(this._catchCacheImage$(configuration.ids.background), this._catchCacheImage$(configuration.ids.foreground)).pipe(map((images) => {
                    return { background: images[0], foreground: images[1] };
                })), this._navigator.stateService.currentState$.pipe(first())).pipe(map((nf) => {
                    return { images: nf[0], state: nf[1].state };
                }));
            }))
                .subscribe((co) => {
                if (co.state.currentImage != null &&
                    co.state.previousImage != null &&
                    co.state.currentImage.id === co.images.foreground.id &&
                    co.state.previousImage.id === co.images.background.id) {
                    return;
                }
                if (co.state.currentImage.id === co.images.background.id) {
                    this._navigator.stateService.setImages([co.images.foreground]);
                    return;
                }
                if (co.state.currentImage.id === co.images.foreground.id &&
                    co.state.trajectory.length === 1) {
                    this._navigator.stateService.prependImages([co.images.background]);
                    return;
                }
                this._navigator.stateService.setImages([co.images.background]);
                this._navigator.stateService.setImages([co.images.foreground]);
            }, (e) => {
                console.error(e);
            }));
            const textureProvider$ = this._container.configurationService.imageTiling$.pipe(switchMap((active) => {
                return active ?
                    this._navigator.stateService.currentState$ :
                    new Subject();
            }), distinctUntilChanged(undefined, (frame) => {
                return frame.state.currentImage.id;
            }), withLatestFrom(this._container.glRenderer.webGLRenderer$, this._container.renderService.size$), map(([frame, renderer, size]) => {
                const state = frame.state;
                Math.max(size.width, size.height);
                const currentImage = state.currentImage;
                const currentTransform = state.currentTransform;
                return new TextureProvider(currentImage.id, currentTransform.basicWidth, currentTransform.basicHeight, currentImage.image, this._imageTileLoader, new TileStore(), renderer);
            }), publishReplay(1), refCount());
            subs.push(textureProvider$.subscribe(() => { }));
            subs.push(textureProvider$.pipe(map((provider) => {
                return (renderer) => {
                    renderer.setTextureProvider(provider.id, provider);
                    return renderer;
                };
            }))
                .subscribe(this._glRendererOperation$));
            subs.push(textureProvider$.pipe(pairwise())
                .subscribe((pair) => {
                let previous = pair[0];
                previous.abort();
            }));
            const roiTrigger$ = this._container.configurationService.imageTiling$.pipe(switchMap((active) => {
                return active ?
                    combineLatest(this._container.renderService.renderCameraFrame$, this._container.renderService.size$.pipe(debounceTime(250))) :
                    new Subject();
            }), map(([camera, size]) => {
                return [
                    camera.camera.position.clone(),
                    camera.camera.lookat.clone(),
                    camera.zoom.valueOf(),
                    size.height.valueOf(),
                    size.width.valueOf()
                ];
            }), pairwise(), skipWhile((pls) => {
                return pls[1][2] - pls[0][2] < 0 || pls[1][2] === 0;
            }), map((pls) => {
                let samePosition = pls[0][0].equals(pls[1][0]);
                let sameLookat = pls[0][1].equals(pls[1][1]);
                let sameZoom = pls[0][2] === pls[1][2];
                let sameHeight = pls[0][3] === pls[1][3];
                let sameWidth = pls[0][4] === pls[1][4];
                return samePosition && sameLookat && sameZoom && sameHeight && sameWidth;
            }), distinctUntilChanged(), filter((stalled) => {
                return stalled;
            }), switchMap(() => {
                return this._container.renderService.renderCameraFrame$.pipe(first());
            }), withLatestFrom(this._container.renderService.size$, this._navigator.stateService.currentTransform$));
            subs.push(textureProvider$.pipe(switchMap((provider) => {
                return roiTrigger$.pipe(map(([camera, size, transform]) => {
                    return [
                        this._roiCalculator.computeRegionOfInterest(camera, size, transform),
                        provider,
                    ];
                }));
            }), filter((args) => {
                return !args[1].disposed;
            }))
                .subscribe((args) => {
                let roi = args[0];
                let provider = args[1];
                provider.setRegionOfInterest(roi);
            }));
            const hasTexture$ = textureProvider$.pipe(switchMap((provider) => {
                return provider.hasTexture$;
            }), startWith(false), publishReplay(1), refCount());
            subs.push(hasTexture$.subscribe(() => { }));
            const textureProviderPrev$ = this._container.configurationService.imageTiling$.pipe(switchMap((active) => {
                return active ?
                    this._navigator.stateService.currentState$ :
                    new Subject();
            }), filter((frame) => {
                return !!frame.state.previousImage;
            }), distinctUntilChanged(undefined, (frame) => {
                return frame.state.previousImage.id;
            }), withLatestFrom(this._container.glRenderer.webGLRenderer$, this._container.renderService.size$), map(([frame, renderer, size]) => {
                const state = frame.state;
                const previousImage = state.previousImage;
                const previousTransform = state.previousTransform;
                return new TextureProvider(previousImage.id, previousTransform.basicWidth, previousTransform.basicHeight, previousImage.image, this._imageTileLoader, new TileStore(), renderer);
            }), publishReplay(1), refCount());
            subs.push(textureProviderPrev$.subscribe(() => { }));
            subs.push(textureProviderPrev$.pipe(map((provider) => {
                return (renderer) => {
                    renderer.setTextureProviderPrev(provider.id, provider);
                    return renderer;
                };
            }))
                .subscribe(this._glRendererOperation$));
            subs.push(textureProviderPrev$.pipe(pairwise())
                .subscribe((pair) => {
                let previous = pair[0];
                previous.abort();
            }));
            const roiTriggerPrev$ = this._container.configurationService.imageTiling$.pipe(switchMap((active) => {
                return active ?
                    combineLatest(this._container.renderService.renderCameraFrame$, this._container.renderService.size$.pipe(debounceTime(250))) :
                    new Subject();
            }), map(([camera, size]) => {
                return [
                    camera.camera.position.clone(),
                    camera.camera.lookat.clone(),
                    camera.zoom.valueOf(),
                    size.height.valueOf(),
                    size.width.valueOf()
                ];
            }), pairwise(), skipWhile((pls) => {
                return pls[1][2] - pls[0][2] < 0 || pls[1][2] === 0;
            }), map((pls) => {
                let samePosition = pls[0][0].equals(pls[1][0]);
                let sameLookat = pls[0][1].equals(pls[1][1]);
                let sameZoom = pls[0][2] === pls[1][2];
                let sameHeight = pls[0][3] === pls[1][3];
                let sameWidth = pls[0][4] === pls[1][4];
                return samePosition && sameLookat && sameZoom && sameHeight && sameWidth;
            }), distinctUntilChanged(), filter((stalled) => {
                return stalled;
            }), switchMap(() => {
                return this._container.renderService.renderCameraFrame$.pipe(first());
            }), withLatestFrom(this._container.renderService.size$, this._navigator.stateService.currentTransform$));
            subs.push(textureProviderPrev$.pipe(switchMap((provider) => {
                return roiTriggerPrev$.pipe(map(([camera, size, transform]) => {
                    return [
                        this._roiCalculator.computeRegionOfInterest(camera, size, transform),
                        provider,
                    ];
                }));
            }), filter((args) => {
                return !args[1].disposed;
            }), withLatestFrom(this._navigator.stateService.currentState$))
                .subscribe(([[roi, provider], frame]) => {
                let shiftedRoi = null;
                if (isSpherical(frame.state.previousImage.cameraType)) {
                    if (isSpherical(frame.state.currentImage.cameraType)) {
                        const currentViewingDirection = this._spatial.viewingDirection(frame.state.currentImage.rotation);
                        const previousViewingDirection = this._spatial.viewingDirection(frame.state.previousImage.rotation);
                        const directionDiff = this._spatial.angleBetweenVector2(currentViewingDirection.x, currentViewingDirection.y, previousViewingDirection.x, previousViewingDirection.y);
                        const shift = directionDiff / (2 * Math.PI);
                        const bbox = {
                            maxX: this._spatial.wrap(roi.bbox.maxX + shift, 0, 1),
                            maxY: roi.bbox.maxY,
                            minX: this._spatial.wrap(roi.bbox.minX + shift, 0, 1),
                            minY: roi.bbox.minY,
                        };
                        shiftedRoi = {
                            bbox: bbox,
                            pixelHeight: roi.pixelHeight,
                            pixelWidth: roi.pixelWidth,
                        };
                    }
                    else {
                        const currentViewingDirection = this._spatial.viewingDirection(frame.state.currentImage.rotation);
                        const previousViewingDirection = this._spatial.viewingDirection(frame.state.previousImage.rotation);
                        const directionDiff = this._spatial.angleBetweenVector2(currentViewingDirection.x, currentViewingDirection.y, previousViewingDirection.x, previousViewingDirection.y);
                        const shiftX = directionDiff / (2 * Math.PI);
                        const a1 = this._spatial.angleToPlane(currentViewingDirection.toArray(), [0, 0, 1]);
                        const a2 = this._spatial.angleToPlane(previousViewingDirection.toArray(), [0, 0, 1]);
                        const shiftY = (a2 - a1) / (2 * Math.PI);
                        const currentTransform = frame.state.currentTransform;
                        const size = Math.max(currentTransform.basicWidth, currentTransform.basicHeight);
                        const hFov = size > 0 ?
                            2 * Math.atan(0.5 * currentTransform.basicWidth / (size * currentTransform.focal)) :
                            Math.PI / 3;
                        const vFov = size > 0 ?
                            2 * Math.atan(0.5 * currentTransform.basicHeight / (size * currentTransform.focal)) :
                            Math.PI / 3;
                        const spanningWidth = hFov / (2 * Math.PI);
                        const spanningHeight = vFov / Math.PI;
                        const basicWidth = (roi.bbox.maxX - roi.bbox.minX) * spanningWidth;
                        const basicHeight = (roi.bbox.maxY - roi.bbox.minY) * spanningHeight;
                        const pixelWidth = roi.pixelWidth * spanningWidth;
                        const pixelHeight = roi.pixelHeight * spanningHeight;
                        const zoomShiftX = (roi.bbox.minX + roi.bbox.maxX) / 2 - 0.5;
                        const zoomShiftY = (roi.bbox.minY + roi.bbox.maxY) / 2 - 0.5;
                        const minX = 0.5 + shiftX + spanningWidth * zoomShiftX - basicWidth / 2;
                        const maxX = 0.5 + shiftX + spanningWidth * zoomShiftX + basicWidth / 2;
                        const minY = 0.5 + shiftY + spanningHeight * zoomShiftY - basicHeight / 2;
                        const maxY = 0.5 + shiftY + spanningHeight * zoomShiftY + basicHeight / 2;
                        const bbox = {
                            maxX: this._spatial.wrap(maxX, 0, 1),
                            maxY: maxY,
                            minX: this._spatial.wrap(minX, 0, 1),
                            minY: minY,
                        };
                        shiftedRoi = {
                            bbox: bbox,
                            pixelHeight: pixelHeight,
                            pixelWidth: pixelWidth,
                        };
                    }
                }
                else {
                    const currentBasicAspect = frame.state.currentTransform.basicAspect;
                    const previousBasicAspect = frame.state.previousTransform.basicAspect;
                    const [[cornerMinX, cornerMinY], [cornerMaxX, cornerMaxY]] = this._getBasicCorners(currentBasicAspect, previousBasicAspect);
                    const basicWidth = cornerMaxX - cornerMinX;
                    const basicHeight = cornerMaxY - cornerMinY;
                    const pixelWidth = roi.pixelWidth / basicWidth;
                    const pixelHeight = roi.pixelHeight / basicHeight;
                    const minX = (basicWidth - 1) / (2 * basicWidth) + roi.bbox.minX / basicWidth;
                    const maxX = (basicWidth - 1) / (2 * basicWidth) + roi.bbox.maxX / basicWidth;
                    const minY = (basicHeight - 1) / (2 * basicHeight) + roi.bbox.minY / basicHeight;
                    const maxY = (basicHeight - 1) / (2 * basicHeight) + roi.bbox.maxY / basicHeight;
                    const bbox = {
                        maxX: maxX,
                        maxY: maxY,
                        minX: minX,
                        minY: minY,
                    };
                    this._clipBoundingBox(bbox);
                    shiftedRoi = {
                        bbox: bbox,
                        pixelHeight: pixelHeight,
                        pixelWidth: pixelWidth,
                    };
                }
                provider.setRegionOfInterest(shiftedRoi);
            }));
            const hasTexturePrev$ = textureProviderPrev$.pipe(switchMap((provider) => {
                return provider.hasTexture$;
            }), startWith(false), publishReplay(1), refCount());
            subs.push(hasTexturePrev$.subscribe(() => { }));
        }
        _deactivate() {
            this._waitSubscription.unsubscribe();
            this._navigator.stateService.state$.pipe(first())
                .subscribe((state) => {
                if (state !== State.Traversing) {
                    this._navigator.stateService.traverse();
                }
            });
            this._glRendererDisposer$.next(null);
            this._domRenderer.deactivate();
            this._subscriptions.unsubscribe();
            this.configure({ ids: null });
        }
        _getDefaultConfiguration() {
            return {
                initialPosition: 1,
                mode: exports.SliderConfigurationMode.Motion,
                sliderVisible: true,
            };
        }
        _catchCacheImage$(imageId) {
            return this._navigator.graphService.cacheImage$(imageId).pipe(catchError((error) => {
                console.error(`Failed to cache slider image (${imageId})`, error);
                return empty();
            }));
        }
        _getBasicCorners(currentAspect, previousAspect) {
            let offsetX;
            let offsetY;
            if (currentAspect > previousAspect) {
                offsetX = 0.5;
                offsetY = 0.5 * currentAspect / previousAspect;
            }
            else {
                offsetX = 0.5 * previousAspect / currentAspect;
                offsetY = 0.5;
            }
            return [[0.5 - offsetX, 0.5 - offsetY], [0.5 + offsetX, 0.5 + offsetY]];
        }
        _clipBoundingBox(bbox) {
            bbox.minX = Math.max(0, Math.min(1, bbox.minX));
            bbox.maxX = Math.max(0, Math.min(1, bbox.maxX));
            bbox.minY = Math.max(0, Math.min(1, bbox.minY));
            bbox.maxY = Math.max(0, Math.min(1, bbox.maxY));
        }
    }
    SliderComponent.componentName = "slider";

    class PlayService {
        constructor(graphService, stateService) {
            this._subscriptions = new SubscriptionHolder();
            this._graphService = graphService;
            this._stateService = stateService;
            const subs = this._subscriptions;
            this._directionSubject$ = new Subject();
            this._direction$ = this._directionSubject$.pipe(startWith(exports.NavigationDirection.Next), publishReplay(1), refCount());
            subs.push(this._direction$.subscribe());
            this._playing = false;
            this._playingSubject$ = new Subject();
            this._playing$ = this._playingSubject$.pipe(startWith(this._playing), publishReplay(1), refCount());
            subs.push(this._playing$.subscribe());
            this._speed = 0.5;
            this._speedSubject$ = new Subject();
            this._speed$ = this._speedSubject$.pipe(startWith(this._speed), publishReplay(1), refCount());
            subs.push(this._speed$.subscribe());
            this._imagesAhead = this._mapImagesAhead(this._mapSpeed(this._speed));
            this._bridging$ = null;
        }
        get playing() {
            return this._playing;
        }
        get direction$() {
            return this._direction$;
        }
        get playing$() {
            return this._playing$;
        }
        get speed$() {
            return this._speed$;
        }
        play() {
            if (this._playing) {
                return;
            }
            this._stateService.cutImages();
            const stateSpeed = this._setSpeed(this._speed);
            this._stateService.setSpeed(stateSpeed);
            this._graphModeSubscription = this._speed$.pipe(map((speed) => {
                return speed > PlayService.sequenceSpeed ? GraphMode.Sequence : GraphMode.Spatial;
            }), distinctUntilChanged())
                .subscribe((mode) => {
                this._graphService.setGraphMode(mode);
            });
            this._cacheSubscription = combineLatest(this._stateService.currentImage$.pipe(map((image) => {
                return [image.sequenceId, image.id];
            }), distinctUntilChanged(undefined, ([sequenceId]) => {
                return sequenceId;
            })), this._graphService.graphMode$, this._direction$).pipe(switchMap(([[sequenceId, imageId], mode, direction]) => {
                if (direction !== exports.NavigationDirection.Next && direction !== exports.NavigationDirection.Prev) {
                    return of([undefined, direction]);
                }
                const sequence$ = (mode === GraphMode.Sequence ?
                    this._graphService.cacheSequenceImages$(sequenceId, imageId) :
                    this._graphService.cacheSequence$(sequenceId)).pipe(retry(3), catchError((error) => {
                    console.error(error);
                    return of(undefined);
                }));
                return combineLatest(sequence$, of(direction));
            }), switchMap(([sequence, direction]) => {
                if (sequence === undefined) {
                    return empty();
                }
                const imageIds = sequence.imageIds.slice();
                if (direction === exports.NavigationDirection.Prev) {
                    imageIds.reverse();
                }
                return this._stateService.currentState$.pipe(map((frame) => {
                    return [frame.state.trajectory[frame.state.trajectory.length - 1].id, frame.state.imagesAhead];
                }), scan(([lastRequestKey, previousRequestKeys], [lastTrajectoryKey, imagesAhead]) => {
                    if (lastRequestKey === undefined) {
                        lastRequestKey = lastTrajectoryKey;
                    }
                    const lastIndex = imageIds.length - 1;
                    if (imagesAhead >= this._imagesAhead || imageIds[lastIndex] === lastRequestKey) {
                        return [lastRequestKey, []];
                    }
                    const current = imageIds.indexOf(lastTrajectoryKey);
                    const start = imageIds.indexOf(lastRequestKey) + 1;
                    const end = Math.min(lastIndex, current + this._imagesAhead - imagesAhead) + 1;
                    if (end <= start) {
                        return [lastRequestKey, []];
                    }
                    return [imageIds[end - 1], imageIds.slice(start, end)];
                }, [undefined, []]), mergeMap(([lastRequestKey, newRequestKeys]) => {
                    return from(newRequestKeys);
                }));
            }), mergeMap((key) => {
                return this._graphService.cacheImage$(key).pipe(catchError(() => {
                    return empty();
                }));
            }, 6))
                .subscribe();
            this._playingSubscription = this._stateService.currentState$.pipe(filter((frame) => {
                return frame.state.imagesAhead < this._imagesAhead;
            }), distinctUntilChanged(undefined, (frame) => {
                return frame.state.lastImage.id;
            }), map((frame) => {
                const lastImage = frame.state.lastImage;
                const trajectory = frame.state.trajectory;
                let increasingTime = undefined;
                for (let i = trajectory.length - 2; i >= 0; i--) {
                    const image = trajectory[i];
                    if (image.sequenceId !== lastImage.sequenceId) {
                        break;
                    }
                    if (image.capturedAt !== lastImage.capturedAt) {
                        increasingTime = image.capturedAt < lastImage.capturedAt;
                        break;
                    }
                }
                return [frame.state.lastImage, increasingTime];
            }), withLatestFrom(this._direction$), switchMap(([[image, increasingTime], direction]) => {
                return zip(([exports.NavigationDirection.Next, exports.NavigationDirection.Prev].indexOf(direction) > -1 ?
                    image.sequenceEdges$ :
                    image.spatialEdges$).pipe(first((status) => {
                    return status.cached;
                }), timeout(15000)), of(direction)).pipe(map(([s, d]) => {
                    for (let edge of s.edges) {
                        if (edge.data.direction === d) {
                            return edge.target;
                        }
                    }
                    return null;
                }), switchMap((key) => {
                    return key != null ?
                        this._graphService.cacheImage$(key) :
                        empty();
                }));
            }))
                .subscribe((image) => {
                this._stateService.appendImagess([image]);
            }, (error) => {
                console.error(error);
                this.stop();
            });
            this._clearSubscription = this._stateService.currentImage$.pipe(bufferCount(1, 10))
                .subscribe((images) => {
                this._stateService.clearPriorImages();
            });
            this._setPlaying(true);
            const currentLastImages$ = this._stateService.currentState$.pipe(map((frame) => {
                return frame.state;
            }), distinctUntilChanged(([kc1, kl1], [kc2, kl2]) => {
                return kc1 === kc2 && kl1 === kl2;
            }, (state) => {
                return [state.currentImage.id, state.lastImage.id];
            }), filter((state) => {
                return state.currentImage.id === state.lastImage.id &&
                    state.currentIndex === state.trajectory.length - 1;
            }), map((state) => {
                return state.currentImage;
            }));
            this._stopSubscription = combineLatest(currentLastImages$, this._direction$).pipe(switchMap(([image, direction]) => {
                const edgeStatus$ = ([exports.NavigationDirection.Next, exports.NavigationDirection.Prev].indexOf(direction) > -1 ?
                    image.sequenceEdges$ :
                    image.spatialEdges$).pipe(first((status) => {
                    return status.cached;
                }), timeout(15000), catchError((error) => {
                    console.error(error);
                    return of({ cached: false, edges: [] });
                }));
                return combineLatest(of(direction), edgeStatus$).pipe(map(([d, es]) => {
                    for (const edge of es.edges) {
                        if (edge.data.direction === d) {
                            return true;
                        }
                    }
                    return false;
                }));
            }), mergeMap((hasEdge) => {
                if (hasEdge || !this._bridging$) {
                    return of(hasEdge);
                }
                return this._bridging$.pipe(map((image) => {
                    return image != null;
                }), catchError((error) => {
                    console.error(error);
                    return of(false);
                }));
            }), first((hasEdge) => {
                return !hasEdge;
            }))
                .subscribe(undefined, undefined, () => { this.stop(); });
            if (this._stopSubscription.closed) {
                this._stopSubscription = null;
            }
            this._earthSubscription = this._stateService.state$
                .pipe(map((state) => {
                return state === State.Earth;
            }), distinctUntilChanged(), first((earth) => {
                return earth;
            }))
                .subscribe(undefined, undefined, () => { this.stop(); });
            if (this._earthSubscription.closed) {
                this._earthSubscription = null;
            }
        }
        dispose() {
            this.stop();
            this._subscriptions.unsubscribe();
        }
        setDirection(direction) {
            this._directionSubject$.next(direction);
        }
        setSpeed(speed) {
            speed = Math.max(0, Math.min(1, speed));
            if (speed === this._speed) {
                return;
            }
            const stateSpeed = this._setSpeed(speed);
            if (this._playing) {
                this._stateService.setSpeed(stateSpeed);
            }
            this._speedSubject$.next(this._speed);
        }
        stop() {
            if (!this._playing) {
                return;
            }
            if (!!this._stopSubscription) {
                if (!this._stopSubscription.closed) {
                    this._stopSubscription.unsubscribe();
                }
                this._stopSubscription = null;
            }
            if (!!this._earthSubscription) {
                if (!this._earthSubscription.closed) {
                    this._earthSubscription.unsubscribe();
                }
                this._earthSubscription = null;
            }
            this._graphModeSubscription.unsubscribe();
            this._graphModeSubscription = null;
            this._cacheSubscription.unsubscribe();
            this._cacheSubscription = null;
            this._playingSubscription.unsubscribe();
            this._playingSubscription = null;
            this._clearSubscription.unsubscribe();
            this._clearSubscription = null;
            this._stateService.setSpeed(1);
            this._stateService.cutImages();
            this._graphService.setGraphMode(GraphMode.Spatial);
            this._setPlaying(false);
        }
        _mapSpeed(speed) {
            const x = 2 * speed - 1;
            return Math.pow(10, x) - 0.2 * x;
        }
        _mapImagesAhead(stateSpeed) {
            return Math.round(Math.max(10, Math.min(50, 8 + 6 * stateSpeed)));
        }
        _setPlaying(playing) {
            this._playing = playing;
            this._playingSubject$.next(playing);
        }
        _setSpeed(speed) {
            this._speed = speed;
            const stateSpeed = this._mapSpeed(this._speed);
            this._imagesAhead = this._mapImagesAhead(stateSpeed);
            return stateSpeed;
        }
    }
    PlayService.sequenceSpeed = 0.54;

    exports.CameraVisualizationMode = void 0;
    (function (CameraVisualizationMode) {
        /**
         * Cameras are hidden.
         */
        CameraVisualizationMode[CameraVisualizationMode["Hidden"] = 0] = "Hidden";
        /**
         * Cameras are shown, all with the same color.
         */
        CameraVisualizationMode[CameraVisualizationMode["Homogeneous"] = 1] = "Homogeneous";
        /**
         * Cameras are shown with colors based on the
         * their clusters.
         */
        CameraVisualizationMode[CameraVisualizationMode["Cluster"] = 2] = "Cluster";
        /**
         * Cameras are shown with colors based on the
         * their connected components.
         */
        CameraVisualizationMode[CameraVisualizationMode["ConnectedComponent"] = 3] = "ConnectedComponent";
        /**
         * Cameras are shown, with colors based on the
         * their sequence.
         */
        CameraVisualizationMode[CameraVisualizationMode["Sequence"] = 4] = "Sequence";
    })(exports.CameraVisualizationMode || (exports.CameraVisualizationMode = {}));

    exports.OriginalPositionMode = void 0;
    (function (OriginalPositionMode) {
        /**
         * Original positions are hidden.
         */
        OriginalPositionMode[OriginalPositionMode["Hidden"] = 0] = "Hidden";
        /**
         * Visualize original positions with altitude change.
         */
        OriginalPositionMode[OriginalPositionMode["Altitude"] = 1] = "Altitude";
        /**
         * Visualize original positions without altitude change,
         * i.e. as flat lines from the camera origin.
         */
        OriginalPositionMode[OriginalPositionMode["Flat"] = 2] = "Flat";
    })(exports.OriginalPositionMode || (exports.OriginalPositionMode = {}));

    class ClusterPoints extends Points {
        constructor(parameters) {
            super();
            this._originalSize = parameters.originalSize;
            const cluster = parameters.cluster;
            const scale = parameters.scale;
            const translation = parameters.translation;
            this._makeAttributes(cluster);
            this.material.size = scale * this._originalSize;
            this.material.vertexColors = true;
            this.material.needsUpdate = true;
            this.matrixAutoUpdate = false;
            this.position.fromArray(translation);
            this.updateMatrix();
            this.updateMatrixWorld(false);
        }
        dispose() {
            this.geometry.dispose();
            this.material.dispose();
        }
        resize(scale) {
            this.material.size = scale * this._originalSize;
            this.material.needsUpdate = true;
        }
        _makeAttributes(cluster) {
            const positions = [];
            const colors = [];
            const points = cluster.points;
            for (const pointId in points) {
                if (!points.hasOwnProperty(pointId)) {
                    continue;
                }
                const point = points[pointId];
                positions.push(...point.coordinates);
                const color = point.color;
                colors.push(color[0]);
                colors.push(color[1]);
                colors.push(color[2]);
            }
            const geometry = this.geometry;
            geometry.setAttribute("position", new BufferAttribute(new Float32Array(positions), 3));
            geometry.setAttribute("color", new BufferAttribute(new Float32Array(colors), 3));
        }
    }

    class CellLine extends Line {
        constructor(vertices) {
            super();
            this._makeAttributes(vertices);
            this.matrixAutoUpdate = false;
            this.updateMatrix();
            this.updateMatrixWorld(false);
        }
        dispose() {
            this.geometry.dispose();
            this.material.dispose();
        }
        _makeAttributes(vertices) {
            const closedPolygon = vertices.slice();
            closedPolygon.push(vertices[0]);
            let index = 0;
            const positions = new Float32Array(3 * (vertices.length + 1));
            for (const vertex of closedPolygon) {
                positions[index++] = vertex[0];
                positions[index++] = vertex[1];
                positions[index++] = vertex[2];
            }
            this.geometry.setAttribute("position", new BufferAttribute(positions, 3));
        }
    }

    // Level 0: 1 x 1 x 1 meter cubes
    const OCTREE_ROOT_LEVEL = 14; // 16384 meters
    const OCTREE_LEAF_LEVEL = 6; // 64 meters
    function isLeafLevel(level, leafLevel) {
        return level === leafLevel;
    }
    function levelToSize(level) {
        return Math.pow(2, level);
    }
    function levelToRootBoundingBox(level) {
        const size = levelToSize(level);
        const half = size / 2;
        const min = [-half, -half, -half];
        const max = [half, half, half];
        return { min, max };
    }

    class SpatialOctreeNode {
        constructor(level, leafLevel, boundingBox, parent) {
            this.level = level;
            this.leafLevel = leafLevel;
            this.boundingBox = boundingBox;
            this.parent = parent;
            this.children = [];
            this.items = [];
            if (parent) {
                parent.children.push(this);
            }
        }
        get isEmpty() {
            return !(this.children.length || this.items.length);
        }
        add(object) {
            const self = this;
            if (!self.boundingBox.containsPoint(object.position)) {
                throw new Error(`Item not contained in node`);
            }
            if (isLeafLevel(self.level, self.leafLevel)) {
                self.items.push(object);
                return this;
            }
            for (const child of self.children) {
                if (child.boundingBox.containsPoint(object.position)) {
                    return child.add(object);
                }
            }
            for (const boundingBox of self._generateBoundingBoxes()) {
                if (boundingBox.containsPoint(object.position)) {
                    const child = new SpatialOctreeNode(self.level - 1, self.leafLevel, boundingBox, self);
                    return child.add(object);
                }
            }
            throw new Error(`Item not contained in children`);
        }
        intersect(ray, target, nodes) {
            if (!ray.intersectBox(this.boundingBox, target)) {
                return;
            }
            if (isLeafLevel(this.level, this.leafLevel)) {
                nodes.push(this);
                return;
            }
            for (const child of this.children) {
                child.intersect(ray, target, nodes);
            }
        }
        remove(object) {
            const index = this.items.indexOf(object);
            if (index < 0) {
                throw new Error(`Item does not exist ${object.uuid}`);
            }
            this.items.splice(index, 1);
        }
        traverse() {
            const self = this;
            if (!self.isEmpty) {
                return;
            }
            const parent = self.parent;
            if (!parent) {
                return;
            }
            const index = parent.children.indexOf(self);
            if (index < 0) {
                throw new Error(`Corrupt octree`);
            }
            parent.children.splice(index, 1);
            this.parent = null;
            parent.traverse();
        }
        _generateBoundingBoxes() {
            const self = this;
            const min = self.boundingBox.min;
            const max = self.boundingBox.max;
            const size = (max.x - min.x) / 2;
            const mins = [
                [min.x, min.y + size, min.z + size],
                [min.x + size, min.y + size, min.z + size],
                [min.x, min.y, min.z + size],
                [min.x + size, min.y, min.z + size],
                [min.x, min.y + size, min.z],
                [min.x + size, min.y + size, min.z],
                [min.x, min.y, min.z],
                [min.x + size, min.y, min.z],
            ];
            const boundingBoxes = [];
            for (const [minX, minY, minZ] of mins) {
                boundingBoxes.push(new Box3(new Vector3(minX, minY, minZ), new Vector3(minX + size, minY + size, minZ + size)));
            }
            return boundingBoxes;
        }
    }

    class SpatialOctree {
        constructor(rootLevel, leafLevel) {
            this.rootLevel = rootLevel;
            this.leafLevel = leafLevel;
            if (leafLevel > rootLevel) {
                throw new Error();
            }
            this._index = new Map();
            this._root = this._makeRoot();
        }
        get root() {
            return this._root;
        }
        add(object) {
            if (!this.root.boundingBox.containsPoint(object.position)) {
                console.warn(`Object outside bounding box ${object.uuid}`);
                return;
            }
            const leaf = this._root.add(object);
            this._index.set(object.uuid, leaf);
        }
        has(object) {
            return this._index.has(object.uuid);
        }
        intersect(ray) {
            const leaves = [];
            const target = new Vector3();
            this._root.intersect(ray, target, leaves);
            return leaves
                .map(leaf => leaf.items)
                .reduce((acc, items) => {
                acc.push(...items);
                return acc;
            }, []);
        }
        reset() {
            this._root = this._makeRoot();
            this._index.clear();
        }
        remove(object) {
            if (!this.has(object)) {
                throw new Error(`Frame does not exist ${object.uuid}`);
            }
            const leaf = this._index.get(object.uuid);
            leaf.remove(object);
            leaf.traverse();
            this._index.delete(object.uuid);
        }
        _makeRoot() {
            const level = this.rootLevel;
            const bbox = levelToRootBoundingBox(level);
            const box = new Box3(new Vector3().fromArray(bbox.min), new Vector3().fromArray(bbox.max));
            return new SpatialOctreeNode(level, this.leafLevel, box);
        }
    }

    class SpatialIntersection {
        constructor(octree, raycaster) {
            this._objects = [];
            this._objectImageMap = new Map();
            this._octree = octree !== null && octree !== void 0 ? octree : new SpatialOctree(OCTREE_ROOT_LEVEL, OCTREE_LEAF_LEVEL);
            this._raycaster = raycaster !== null && raycaster !== void 0 ? raycaster : new Raycaster();
            this._interactiveLayer = 1;
            this._raycaster = !!raycaster ?
                raycaster :
                new Raycaster(undefined, undefined, 1, 10000);
            this._lineThreshold = 0.2;
            this._largeLineThreshold = 0.4;
            this._raycaster.params.Line.threshold = this._lineThreshold;
            this._raycaster.layers.set(this._interactiveLayer);
        }
        get interactiveLayer() { return this._interactiveLayer; }
        get octree() { return this._octree; }
        get raycaster() { return this._raycaster; }
        add(object, imageId) {
            const uuid = object.uuid;
            this._objectImageMap.set(uuid, imageId);
            this._objects.push(object);
            this._octree.add(object);
        }
        intersectObjects(viewport, camera) {
            this._raycaster.setFromCamera(new Vector2().fromArray(viewport), camera);
            const objects = this._octree.intersect(this.raycaster.ray);
            const intersects = this._raycaster.intersectObjects(objects);
            const onMap = this._objectImageMap;
            for (const intersect of intersects) {
                const uuid = intersect.object.uuid;
                if (!onMap.has(uuid)) {
                    continue;
                }
                return onMap.get(uuid);
            }
            return null;
        }
        remove(object) {
            const objects = this._objects;
            const index = objects.indexOf(object);
            if (index !== -1) {
                const deleted = objects.splice(index, 1);
                for (const d of deleted) {
                    this._objectImageMap.delete(d.uuid);
                }
                this._octree.remove(object);
            }
            else {
                console.warn(`Object does not exist`);
            }
        }
        resetIntersectionThreshold(useLarge) {
            this._raycaster.params.Line.threshold = useLarge ?
                this._largeLineThreshold :
                this._lineThreshold;
        }
    }

    class PositionLine extends Line {
        constructor(parameters) {
            super(parameters.geometry, parameters.material);
            const mode = parameters.mode;
            const originalOrigin = parameters.originalOrigin;
            const transform = parameters.transform;
            const origin = transform.unprojectBasic([0, 0], 0);
            this._relativeAltitude = originalOrigin[2] - origin[2];
            this._makeAttributes(origin, originalOrigin, mode);
            this.matrixAutoUpdate = false;
            this.position.fromArray(origin);
            this.updateMatrix();
            this.updateMatrixWorld(false);
        }
        dispose() {
            this.geometry.dispose();
            this.material.dispose();
        }
        setMode(mode) {
            const positionAttribute = this.geometry.attributes.position;
            const positions = positionAttribute.array;
            positions[5] = this._modeToAltitude(mode);
            positionAttribute.needsUpdate = true;
            this.geometry.computeBoundingSphere();
        }
        _makeAttributes(origin, originalOrigin, mode) {
            const positions = new Float32Array(6);
            positions[0] = 0;
            positions[1] = 0;
            positions[2] = 0;
            positions[3] = originalOrigin[0] - origin[0];
            positions[4] = originalOrigin[1] - origin[1];
            positions[5] = this._modeToAltitude(mode);
            const attribute = new BufferAttribute(positions, 3);
            this.geometry.setAttribute("position", attribute);
            attribute.needsUpdate = true;
            this.geometry.computeBoundingSphere();
        }
        _modeToAltitude(mode) {
            return mode === exports.OriginalPositionMode.Altitude ?
                this._relativeAltitude : 0;
        }
    }

    class CameraFrameBase extends LineSegments {
        constructor(parameters) {
            super(parameters.geometry, parameters.material);
            const color = parameters.color;
            const size = parameters.size;
            const scale = parameters.scale;
            const transform = parameters.transform;
            const origin = transform.unprojectBasic([0, 0], 0);
            const positions = this._makePositions(size, transform, origin);
            this._makeAttributes(positions, color);
            this.geometry.computeBoundingSphere();
            this.geometry.computeBoundingBox();
            this.matrixAutoUpdate = false;
            this.position.fromArray(origin);
            this.scale.set(scale, scale, scale);
            this.updateMatrix();
            this.updateMatrixWorld(false);
        }
        dispose() {
            this.geometry.dispose();
            this.material.dispose();
        }
        setColor(color) {
            this._updateColorAttribute(color);
            return this;
        }
        resize(scale) {
            this.scale.set(scale, scale, scale);
            this.updateMatrix();
            this.updateMatrixWorld(false);
            return this;
        }
        _makeAttributes(positions, color) {
            const geometry = this.geometry;
            const positionAttribute = new BufferAttribute(new Float32Array(positions), 3);
            geometry.setAttribute("position", positionAttribute);
            positionAttribute.needsUpdate = true;
            const colorAttribute = new BufferAttribute(new Float32Array(positions.length), 3);
            geometry.setAttribute("color", colorAttribute);
            this._updateColorAttribute(color);
        }
        _updateColorAttribute(color) {
            const [r, g, b] = new Color(color).toArray();
            const colorAttribute = this.geometry.attributes.color;
            const colors = colorAttribute.array;
            const length = colors.length;
            let index = 0;
            for (let i = 0; i < length; i++) {
                colors[index++] = r;
                colors[index++] = g;
                colors[index++] = b;
            }
            colorAttribute.needsUpdate = true;
        }
    }

    class SphericalCameraFrame extends CameraFrameBase {
        _makePositions(size, transform, origin) {
            const vs = 10;
            const positions = [];
            positions.push(...this._makeAxis(size, transform, origin));
            positions.push(...this._makeLat(0.5, vs, size, transform, origin));
            for (const lat of [0, 0.25, 0.5, 0.75]) {
                positions
                    .push(...this._makeLng(lat, vs, size, transform, origin));
            }
            return positions;
        }
        _makeAxis(size, transform, origin) {
            const south = transform.unprojectBasic([0.5, 1], 0.8 * size);
            const north = transform.unprojectBasic([0.5, 0], 1.2 * size);
            return [
                south[0] - origin[0],
                south[1] - origin[1],
                south[2] - origin[2],
                north[0] - origin[0],
                north[1] - origin[1],
                north[2] - origin[2],
            ];
        }
        _makeLat(basicY, numVertices, size, transform, origin) {
            const dist = 0.8 * size;
            const [originX, originY, originZ] = origin;
            const positions = [];
            const first = transform.unprojectBasic([0, basicY], dist);
            first[0] -= originX;
            first[1] -= originY;
            first[2] -= originZ;
            positions.push(...first);
            for (let i = 1; i <= numVertices; i++) {
                const position = transform.unprojectBasic([i / numVertices, basicY], dist);
                position[0] -= originX;
                position[1] -= originY;
                position[2] -= originZ;
                positions.push(...position, ...position);
            }
            positions.push(...first);
            return positions;
        }
        _makeLng(basicX, numVertices, size, transform, origin) {
            const dist = 0.8 * size;
            const [originX, originY, originZ] = origin;
            const positions = [];
            const first = transform.unprojectBasic([basicX, 0], dist);
            first[0] -= originX;
            first[1] -= originY;
            first[2] -= originZ;
            positions.push(...first);
            for (let i = 0; i <= numVertices; i++) {
                const position = transform.unprojectBasic([basicX, i / numVertices], dist);
                position[0] -= originX;
                position[1] -= originY;
                position[2] -= originZ;
                positions.push(...position, ...position);
            }
            positions.push(...first);
            return positions;
        }
    }

    class PerspectiveCameraFrame extends CameraFrameBase {
        _makePositions(size, transform, origin) {
            const samples = 8;
            const positions = [];
            positions.push(...this._makeDiags(size, transform, origin));
            positions.push(...this._makeFrame(size, samples, transform, origin));
            return positions;
        }
        _makeDiags(size, transform, origin) {
            const depth = size;
            const [originX, originY, originZ] = origin;
            const cameraCenter = [0, 0, 0];
            const positions = [];
            for (const vertex2d of [[0, 0], [1, 0], [1, 1], [0, 1]]) {
                const corner = transform.unprojectBasic(vertex2d, depth, true);
                corner[0] -= originX;
                corner[1] -= originY;
                corner[2] -= originZ;
                positions.push(...cameraCenter, ...corner);
            }
            return positions;
        }
        _makeFrame(size, samples, transform, origin) {
            const vertices2d = [];
            vertices2d.push(...this._subsample([0, 1], [0, 0], samples));
            vertices2d.push(...this._subsample([0, 0], [1, 0], samples));
            vertices2d.push(...this._subsample([1, 0], [1, 1], samples));
            const depth = size;
            const [originX, originY, originZ] = origin;
            const positions = [];
            for (const vertex2d of vertices2d) {
                const position = transform.unprojectBasic(vertex2d, depth, true);
                position[0] -= originX;
                position[1] -= originY;
                position[2] -= originZ;
                positions.push(...position);
            }
            return positions;
        }
        _interpolate(a, b, alpha) {
            return a + alpha * (b - a);
        }
        _subsample(p1, p2, subsamples) {
            if (subsamples < 1) {
                return [p1, p2];
            }
            const samples = [];
            samples.push(p1);
            for (let i = 0; i <= subsamples; i++) {
                const p = [];
                for (let j = 0; j < 3; j++) {
                    p.push(this._interpolate(p1[j], p2[j], i / (subsamples + 1)));
                }
                samples.push(p);
                samples.push(p);
            }
            samples.push(p2);
            return samples;
        }
    }

    class SpatialCell {
        constructor(id, _scene, _intersection) {
            this.id = id;
            this._scene = _scene;
            this._intersection = _intersection;
            this.cameras = new Object3D();
            this.keys = [];
            this._positionLines = {};
            this._positions = new Object3D();
            this._cameraFrames = {};
            this._clusters = new Map();
            this._connectedComponents = new Map();
            this._sequences = new Map();
            this._props = {};
            this.clusterVisibles = {};
            this._frameMaterial = new LineBasicMaterial({
                fog: false,
                vertexColors: true,
            });
            this._positionMaterial = new LineBasicMaterial({
                fog: false,
                color: 0xff0000,
            });
            this._scene.add(this.cameras, this._positions);
        }
        addImage(props) {
            const image = props.image;
            const id = image.id;
            if (this.hasImage(id)) {
                throw new Error(`Image exists ${id}`);
            }
            const ccId = props.idMap.ccId;
            if (!(this._connectedComponents.has(ccId))) {
                this._connectedComponents.set(ccId, []);
            }
            const cId = props.idMap.clusterId;
            if (!this._clusters.has(cId)) {
                this._clusters.set(cId, []);
            }
            const sId = props.idMap.sequenceId;
            if (!this._sequences.has(sId)) {
                this._sequences.set(sId, []);
            }
            this._props[id] = {
                image: image,
                ids: { ccId, clusterId: cId, sequenceId: sId },
            };
            this.keys.push(id);
        }
        applyCameraColor(imageId, color) {
            this._cameraFrames[imageId].setColor(color);
        }
        applyCameraSize(size) {
            for (const camera of this.cameras.children) {
                camera.resize(size);
            }
        }
        applyFilter(filter) {
            var _a;
            const clusterVisibles = this.clusterVisibles;
            for (const clusterId in clusterVisibles) {
                if (!clusterVisibles.hasOwnProperty(clusterId)) {
                    continue;
                }
                clusterVisibles[clusterId] = false;
            }
            const cameraFrames = this._cameraFrames;
            const positionLines = this._positionLines;
            const interactiveLayer = this._intersection.interactiveLayer;
            for (const props of Object.values(this._props)) {
                const image = props.image;
                const visible = filter(image);
                const key = image.id;
                positionLines[key].visible = visible;
                const camera = cameraFrames[key];
                this._setCameraVisibility(camera, visible, interactiveLayer);
                clusterVisibles[_a = props.ids.clusterId] || (clusterVisibles[_a] = visible);
            }
        }
        applyPositionMode(mode) {
            this._positions.visible =
                mode !== exports.OriginalPositionMode.Hidden;
            for (const position of this._positions.children) {
                position.setMode(mode);
            }
        }
        dispose() {
            this._disposeCameras();
            this._disposePositions();
            this._scene = null;
            this._intersection = null;
        }
        getCamerasByMode(mode) {
            if (mode === exports.CameraVisualizationMode.Cluster) {
                return this._clusters;
            }
            else if (mode === exports.CameraVisualizationMode.ConnectedComponent) {
                return this._connectedComponents;
            }
            else if (mode === exports.CameraVisualizationMode.Sequence) {
                return this._sequences;
            }
            const cvm = exports.CameraVisualizationMode;
            const defaultId = cvm[cvm.Homogeneous];
            const cameras = new Map();
            cameras.set(defaultId, this.cameras.children);
            return cameras;
        }
        getColorId(imageId, mode) {
            const props = this._props[imageId];
            const cvm = exports.CameraVisualizationMode;
            switch (mode) {
                case cvm.Cluster:
                    return props.ids.clusterId;
                case cvm.ConnectedComponent:
                    return props.ids.ccId;
                case cvm.Sequence:
                    return props.ids.sequenceId;
                default:
                    return cvm[cvm.Homogeneous];
            }
        }
        hasImage(key) {
            return this.keys.indexOf(key) !== -1;
        }
        visualize(props) {
            var _a, _b;
            const id = props.id;
            const visible = props.visible;
            const transform = props.transform;
            const cameraParameters = {
                color: props.color,
                material: this._frameMaterial,
                scale: props.scale,
                size: props.maxSize,
                transform,
            };
            const camera = isSpherical(transform.cameraType) ?
                new SphericalCameraFrame(cameraParameters) :
                new PerspectiveCameraFrame(cameraParameters);
            const interactiveLayer = this._intersection.interactiveLayer;
            this._setCameraVisibility(camera, visible, interactiveLayer);
            this.cameras.add(camera);
            this._cameraFrames[id] = camera;
            const intersection = this._intersection;
            intersection.add(camera, id);
            const ids = this._props[id].ids;
            (_a = this.clusterVisibles)[_b = ids.clusterId] || (_a[_b] = visible);
            this._connectedComponents.get(ids.ccId).push(camera);
            this._clusters.get(ids.clusterId).push(camera);
            this._sequences.get(ids.sequenceId).push(camera);
            const positionParameters = {
                material: this._positionMaterial,
                mode: props.positionMode,
                originalOrigin: props.originalPosition,
                transform,
            };
            const position = new PositionLine(positionParameters);
            position.visible = visible;
            this._positions.add(position);
            this._positionLines[id] = position;
        }
        _disposeCameras() {
            const intersection = this._intersection;
            const cameras = this.cameras;
            for (const camera of cameras.children.slice()) {
                camera.dispose();
                intersection.remove(camera);
                cameras.remove(camera);
            }
            this._scene.remove(this.cameras);
        }
        _disposePositions() {
            const positions = this._positions;
            for (const position of positions.children.slice()) {
                position.dispose();
                positions.remove(position);
            }
            this._scene.remove(this._positions);
        }
        _setCameraVisibility(camera, visible, layer) {
            camera.visible = visible;
            if (visible) {
                camera.layers.enable(layer);
            }
            else {
                camera.layers.disable(layer);
            }
        }
    }

    class SpatialAssets {
        constructor() {
            this._colors = new Map();
            const cvm = exports.CameraVisualizationMode;
            this._colors.set(cvm[cvm.Homogeneous], "#FFFFFF");
        }
        getColor(id) {
            const colors = this._colors;
            if (!colors.has(id)) {
                colors.set(id, this._randomColor());
            }
            return colors.get(id);
        }
        _randomColor() {
            return `hsl(${Math.floor(360 * Math.random())}, 100%, 50%)`;
        }
    }

    function isModeVisible(mode) {
        return mode !== exports.CameraVisualizationMode.Hidden;
    }
    function isOverviewState(state) {
        return state === State.Custom || state === State.Earth;
    }

    const NO_CLUSTER_ID = "NO_CLUSTER_ID";
    const NO_MERGE_ID = "NO_MERGE_ID";
    const NO_SEQUENCE_ID = "NO_SEQUENCE_ID";
    class SpatialScene {
        constructor(configuration, scene) {
            this._rayNearScale = 1.1;
            this._originalPointSize = 2;
            this._originalCameraSize = 2;
            this._imageCellMap = new Map();
            this._scene = !!scene ? scene : new Scene();
            this._scene.autoUpdate = false;
            this._intersection = new SpatialIntersection();
            this._assets = new SpatialAssets();
            this._needsRender = false;
            this._images = {};
            this._cells = {};
            this._cellClusters = {};
            this._clusters = {};
            this._cameraVisualizationMode =
                !!configuration.cameraVisualizationMode ?
                    configuration.cameraVisualizationMode :
                    exports.CameraVisualizationMode.Homogeneous;
            this._cameraSize = configuration.cameraSize;
            this._pointSize = configuration.pointSize;
            this._pointsVisible = configuration.pointsVisible;
            this._positionMode = configuration.originalPositionMode;
            this._cellsVisible = configuration.cellsVisible;
            this._hoveredId = null;
            this._selectedId = null;
            this._colors = { hover: "#FF0000", select: "#FF8000" };
            this._filter = () => true;
        }
        get needsRender() { return this._needsRender; }
        get intersection() {
            return this._intersection;
        }
        addCluster(reconstruction, translation, cellId) {
            if (this.hasCluster(reconstruction.id, cellId)) {
                return;
            }
            const clusterId = reconstruction.id;
            if (!(clusterId in this._clusters)) {
                this._clusters[clusterId] = {
                    points: new Object3D(),
                    cellIds: [],
                };
                const visible = this._getClusterVisible(clusterId);
                this._clusters[clusterId].points.visible = visible;
                this._clusters[clusterId].points.add(new ClusterPoints({
                    cluster: reconstruction,
                    originalSize: this._originalPointSize,
                    scale: this._pointSize,
                    translation,
                }));
                this._scene.add(this._clusters[clusterId].points);
            }
            if (this._clusters[clusterId].cellIds.indexOf(cellId) === -1) {
                this._clusters[clusterId].cellIds.push(cellId);
            }
            if (!(cellId in this._cellClusters)) {
                this._cellClusters[cellId] = { keys: [] };
            }
            if (this._cellClusters[cellId].keys.indexOf(clusterId) === -1) {
                this._cellClusters[cellId].keys.push(clusterId);
            }
            this._needsRender = true;
        }
        addImage(image, transform, originalPosition, cellId) {
            var _a, _b, _c;
            const imageId = image.id;
            const idMap = {
                clusterId: (_a = image.clusterId) !== null && _a !== void 0 ? _a : NO_CLUSTER_ID,
                sequenceId: (_b = image.sequenceId) !== null && _b !== void 0 ? _b : NO_SEQUENCE_ID,
                ccId: (_c = image.mergeId) !== null && _c !== void 0 ? _c : NO_MERGE_ID,
            };
            if (!(cellId in this._images)) {
                const created = new SpatialCell(cellId, this._scene, this._intersection);
                created.cameras.visible =
                    isModeVisible(this._cameraVisualizationMode);
                created.applyPositionMode(this._positionMode);
                this._images[cellId] = created;
            }
            const cell = this._images[cellId];
            if (cell.hasImage(imageId)) {
                return;
            }
            cell.addImage({ idMap, image: image });
            const colorId = cell.getColorId(imageId, this._cameraVisualizationMode);
            const color = this._assets.getColor(colorId);
            const visible = this._filter(image);
            cell.visualize({
                id: imageId,
                color,
                positionMode: this._positionMode,
                scale: this._cameraSize,
                transform,
                visible,
                maxSize: this._originalCameraSize,
                originalPosition
            });
            this._imageCellMap.set(imageId, cellId);
            if (imageId === this._selectedId) {
                this._highlight(imageId, this._colors.select, this._cameraVisualizationMode);
            }
            if (idMap.clusterId in this._clusters) {
                const clusterVisible = this._getClusterVisible(idMap.clusterId);
                this._clusters[idMap.clusterId].points.visible = clusterVisible;
            }
            this._needsRender = true;
        }
        addCell(vertices, cellId) {
            if (this.hasCell(cellId)) {
                return;
            }
            const cell = new CellLine(vertices);
            this._cells[cellId] = new Object3D();
            this._cells[cellId].visible = this._cellsVisible;
            this._cells[cellId].add(cell);
            this._scene.add(this._cells[cellId]);
            this._needsRender = true;
        }
        deactivate() {
            this._filter = () => true;
            this._selectedId = null;
            this._hoveredId = null;
            this.uncache();
        }
        hasCluster(clusterId, cellId) {
            return clusterId in this._clusters &&
                this._clusters[clusterId].cellIds.indexOf(cellId) !== -1;
        }
        hasCell(cellId) {
            return cellId in this._cells;
        }
        hasImage(imageId, cellId) {
            return cellId in this._images &&
                this._images[cellId].hasImage(imageId);
        }
        setCameraSize(cameraSize) {
            if (Math.abs(cameraSize - this._cameraSize) < 1e-3) {
                return;
            }
            const imageCells = this._images;
            for (const cellId of Object.keys(imageCells)) {
                imageCells[cellId].applyCameraSize(cameraSize);
            }
            this._intersection.raycaster.near = this._getNear(cameraSize);
            this._cameraSize = cameraSize;
            this._needsRender = true;
        }
        setFilter(filter) {
            this._filter = filter;
            const clusterVisibles = {};
            for (const imageCell of Object.values(this._images)) {
                imageCell.applyFilter(filter);
                const imageCV = imageCell.clusterVisibles;
                for (const clusterId in imageCV) {
                    if (!imageCV.hasOwnProperty(clusterId)) {
                        continue;
                    }
                    if (!(clusterId in clusterVisibles)) {
                        clusterVisibles[clusterId] = false;
                    }
                    clusterVisibles[clusterId] || (clusterVisibles[clusterId] = imageCV[clusterId]);
                }
            }
            const pointsVisible = this._pointsVisible;
            for (const clusterId in clusterVisibles) {
                if (!clusterVisibles.hasOwnProperty(clusterId)) {
                    continue;
                }
                clusterVisibles[clusterId] && (clusterVisibles[clusterId] = pointsVisible);
                const visible = clusterVisibles[clusterId];
                if (clusterId in this._clusters) {
                    this._clusters[clusterId].points.visible = visible;
                }
            }
            this._needsRender = true;
        }
        setHoveredImage(imageId) {
            if (imageId != null && !this._imageCellMap.has(imageId)) {
                throw new MapillaryError(`Image does not exist: ${imageId}`);
            }
            if (this._hoveredId === imageId) {
                return;
            }
            this._needsRender = true;
            if (this._hoveredId != null) {
                if (this._hoveredId === this._selectedId) {
                    this._highlight(this._hoveredId, this._colors.select, this._cameraVisualizationMode);
                }
                else {
                    this._resetCameraColor(this._hoveredId);
                }
            }
            this._highlight(imageId, this._colors.hover, this._cameraVisualizationMode);
            this._hoveredId = imageId;
        }
        setNavigationState(isOverview) {
            this._intersection.resetIntersectionThreshold(isOverview);
        }
        setPointSize(pointSize) {
            if (Math.abs(pointSize - this._pointSize) < 1e-3) {
                return;
            }
            const clusters = this._clusters;
            for (const key in clusters) {
                if (!clusters.hasOwnProperty(key)) {
                    continue;
                }
                for (const points of clusters[key].points.children) {
                    points.resize(pointSize);
                }
            }
            this._pointSize = pointSize;
            this._needsRender = true;
        }
        setPointVisibility(visible) {
            if (visible === this._pointsVisible) {
                return;
            }
            for (const clusterId in this._clusters) {
                if (!this._clusters.hasOwnProperty(clusterId)) {
                    continue;
                }
                this._clusters[clusterId].points.visible = visible;
            }
            this._pointsVisible = visible;
            this._needsRender = true;
        }
        setPositionMode(mode) {
            if (mode === this._positionMode) {
                return;
            }
            for (const cell of Object.values(this._images)) {
                cell.applyPositionMode(mode);
            }
            this._positionMode = mode;
            this._needsRender = true;
        }
        setSelectedImage(id) {
            if (this._selectedId === id) {
                return;
            }
            this._needsRender = true;
            if (this._selectedId != null) {
                this._resetCameraColor(this._selectedId);
            }
            this._highlight(id, this._colors.select, this._cameraVisualizationMode);
            this._selectedId = id;
        }
        setCellVisibility(visible) {
            if (visible === this._cellsVisible) {
                return;
            }
            for (const cellId in this._cells) {
                if (!this._cells.hasOwnProperty(cellId)) {
                    continue;
                }
                this._cells[cellId].visible = visible;
            }
            this._cellsVisible = visible;
            this._needsRender = true;
        }
        setCameraVisualizationMode(mode) {
            if (mode === this._cameraVisualizationMode) {
                return;
            }
            const visible = isModeVisible(mode);
            const assets = this._assets;
            for (const cell of Object.values(this._images)) {
                cell.cameras.visible = visible;
                const cameraMap = cell.getCamerasByMode(mode);
                cameraMap.forEach((cameras, colorId) => {
                    const color = assets.getColor(colorId);
                    for (const camera of cameras) {
                        camera.setColor(color);
                    }
                });
            }
            this._highlight(this._hoveredId, this._colors.hover, mode);
            this._highlight(this._selectedId, this._colors.select, mode);
            this._cameraVisualizationMode = mode;
            this._needsRender = true;
        }
        render(camera, renderer) {
            renderer.render(this._scene, camera);
            this._needsRender = false;
        }
        uncache(keepCellIds) {
            for (const cellId of Object.keys(this._cellClusters)) {
                if (!!keepCellIds && keepCellIds.indexOf(cellId) !== -1) {
                    continue;
                }
                this._disposeReconstruction(cellId);
            }
            for (const cellId of Object.keys(this._images)) {
                if (!!keepCellIds && keepCellIds.indexOf(cellId) !== -1) {
                    continue;
                }
                const nceMap = this._imageCellMap;
                const keys = this._images[cellId].keys;
                for (const key of keys) {
                    nceMap.delete(key);
                }
                this._images[cellId].dispose();
                delete this._images[cellId];
            }
            for (const cellId of Object.keys(this._cells)) {
                if (!!keepCellIds && keepCellIds.indexOf(cellId) !== -1) {
                    continue;
                }
                this._disposeCell(cellId);
            }
            this._needsRender = true;
        }
        _getClusterVisible(clusterId) {
            if (!this._pointsVisible) {
                return false;
            }
            let visible = false;
            for (const imageCell of Object.values(this._images)) {
                const imageCV = imageCell.clusterVisibles;
                if (!(clusterId in imageCV)) {
                    continue;
                }
                visible || (visible = imageCV[clusterId]);
            }
            return visible;
        }
        _disposePoints(cellId) {
            for (const clusterId of this._cellClusters[cellId].keys) {
                if (!(clusterId in this._clusters)) {
                    continue;
                }
                const index = this._clusters[clusterId].cellIds.indexOf(cellId);
                if (index === -1) {
                    continue;
                }
                this._clusters[clusterId].cellIds.splice(index, 1);
                if (this._clusters[clusterId].cellIds.length > 0) {
                    continue;
                }
                for (const points of this._clusters[clusterId].points.children.slice()) {
                    points.dispose();
                }
                this._scene.remove(this._clusters[clusterId].points);
                delete this._clusters[clusterId];
            }
        }
        _disposeReconstruction(cellId) {
            this._disposePoints(cellId);
            delete this._cellClusters[cellId];
        }
        _disposeCell(cellId) {
            const cell = this._cells[cellId];
            for (const line of cell.children.slice()) {
                line.dispose();
                cell.remove(line);
            }
            this._scene.remove(cell);
            delete this._cells[cellId];
        }
        _getNear(cameraSize) {
            const near = this._rayNearScale *
                this._originalCameraSize *
                cameraSize;
            return Math.max(1, near);
        }
        _resetCameraColor(imageId) {
            const nceMap = this._imageCellMap;
            if (imageId == null || !nceMap.has(imageId)) {
                return;
            }
            const cellId = nceMap.get(imageId);
            const cell = this._images[cellId];
            const colorId = cell.getColorId(imageId, this._cameraVisualizationMode);
            const color = this._assets.getColor(colorId);
            cell.applyCameraColor(imageId, color);
        }
        _highlight(imageId, color, mode) {
            const nceMap = this._imageCellMap;
            if (imageId == null || !nceMap.has(imageId)) {
                return;
            }
            const cellId = nceMap.get(imageId);
            color = mode === exports.CameraVisualizationMode.Homogeneous ?
                color : "#FFFFFF";
            this._images[cellId].applyCameraColor(imageId, color);
        }
    }

    class SpatialCache {
        constructor(graphService, provider) {
            this._graphService = graphService;
            this._data = provider;
            this._cells = {};
            this._cacheRequests = {};
            this._clusters = {};
            this._clusterCells = {};
            this._cellClusters = {};
            this._cachingCells$ = {};
            this._cachingClusters$ = {};
        }
        cacheClusters$(cellId) {
            if (!this.hasCell(cellId)) {
                throw new Error("Cannot cache reconstructions of a non-existing cell.");
            }
            if (this.hasClusters(cellId)) {
                throw new Error("Cannot cache reconstructions that already exists.");
            }
            if (this.isCachingClusters(cellId)) {
                return this._cachingClusters$[cellId];
            }
            const duplicatedClusters = this.getCell(cellId)
                .filter((n) => {
                return !!n.clusterId && !!n.clusterUrl;
            })
                .map((n) => {
                return { key: n.clusterId, url: n.clusterUrl };
            });
            const clusters = Array
                .from(new Map(duplicatedClusters.map((cd) => {
                return [cd.key, cd];
            }))
                .values());
            this._cellClusters[cellId] = clusters;
            this._cacheRequests[cellId] = [];
            let aborter;
            const abort = new Promise((_, reject) => {
                aborter = reject;
            });
            this._cacheRequests[cellId].push(aborter);
            this._cachingClusters$[cellId] =
                this._cacheClusters$(clusters, cellId, abort).pipe(finalize(() => {
                    if (cellId in this._cachingClusters$) {
                        delete this._cachingClusters$[cellId];
                    }
                    if (cellId in this._cacheRequests) {
                        delete this._cacheRequests[cellId];
                    }
                }), publish(), refCount());
            return this._cachingClusters$[cellId];
        }
        cacheCell$(cellId) {
            if (this.hasCell(cellId)) {
                throw new Error("Cannot cache cell that already exists.");
            }
            if (this.isCachingCell(cellId)) {
                return this._cachingCells$[cellId];
            }
            this._cachingCells$[cellId] = this._graphService.cacheCell$(cellId).pipe(catchError((error) => {
                console.error(error);
                return empty();
            }), filter(() => {
                return !(cellId in this._cells);
            }), tap((images) => {
                this._cells[cellId] = [];
                this._cells[cellId].push(...images);
                delete this._cachingCells$[cellId];
            }), finalize(() => {
                if (cellId in this._cachingCells$) {
                    delete this._cachingCells$[cellId];
                }
            }), publish(), refCount());
            return this._cachingCells$[cellId];
        }
        isCachingClusters(cellId) {
            return cellId in this._cachingClusters$;
        }
        isCachingCell(cellId) {
            return cellId in this._cachingCells$;
        }
        hasClusters(cellId) {
            if (cellId in this._cachingClusters$ ||
                !(cellId in this._cellClusters)) {
                return false;
            }
            for (const cd of this._cellClusters[cellId]) {
                if (!(cd.key in this._clusters)) {
                    return false;
                }
            }
            return true;
        }
        hasCell(cellId) {
            return !(cellId in this._cachingCells$) && cellId in this._cells;
        }
        getClusters(cellId) {
            return cellId in this._cellClusters ?
                this._cellClusters[cellId]
                    .map((cd) => {
                    return this._clusters[cd.key];
                })
                    .filter((reconstruction) => {
                    return !!reconstruction;
                }) :
                [];
        }
        getCell(cellId) {
            return cellId in this._cells ? this._cells[cellId] : [];
        }
        uncache(keepCellIds) {
            for (let cellId of Object.keys(this._cacheRequests)) {
                if (!!keepCellIds && keepCellIds.indexOf(cellId) !== -1) {
                    continue;
                }
                for (const aborter of this._cacheRequests[cellId]) {
                    aborter();
                }
                delete this._cacheRequests[cellId];
            }
            for (let cellId of Object.keys(this._cellClusters)) {
                if (!!keepCellIds && keepCellIds.indexOf(cellId) !== -1) {
                    continue;
                }
                for (const cd of this._cellClusters[cellId]) {
                    if (!(cd.key in this._clusterCells)) {
                        continue;
                    }
                    const index = this._clusterCells[cd.key].indexOf(cellId);
                    if (index === -1) {
                        continue;
                    }
                    this._clusterCells[cd.key].splice(index, 1);
                    if (this._clusterCells[cd.key].length > 0) {
                        continue;
                    }
                    delete this._clusterCells[cd.key];
                    delete this._clusters[cd.key];
                }
                delete this._cellClusters[cellId];
            }
            for (let cellId of Object.keys(this._cells)) {
                if (!!keepCellIds && keepCellIds.indexOf(cellId) !== -1) {
                    continue;
                }
                delete this._cells[cellId];
            }
        }
        updateCell$(cellId) {
            if (!this.hasCell(cellId)) {
                throw new Error("Cannot update cell that does not exists.");
            }
            return this._graphService.cacheCell$(cellId).pipe(catchError((error) => {
                console.error(error);
                return empty();
            }), filter(() => {
                return cellId in this._cells;
            }), tap((images) => {
                this._cells[cellId] = [];
                this._cells[cellId].push(...images);
            }), publish(), refCount());
        }
        updateClusters$(cellId) {
            if (!this.hasCell(cellId)) {
                throw new Error("Cannot update reconstructions of a non-existing cell.");
            }
            if (!this.hasClusters(cellId)) {
                throw new Error("Cannot update reconstructions for cell that is not cached.");
            }
            const duplicatedClusters = this.getCell(cellId)
                .filter((n) => {
                return !!n.clusterId && !!n.clusterUrl;
            })
                .map((n) => {
                return { key: n.clusterId, url: n.clusterUrl };
            });
            const clusters = Array
                .from(new Map(duplicatedClusters.map((cd) => {
                return [cd.key, cd];
            }))
                .values())
                .filter(cd => {
                return !(cd.key in this._clusters);
            });
            this._cellClusters[cellId].push(...clusters);
            return this._cacheClusters$(clusters, cellId, null);
        }
        _cacheClusters$(clusters, cellId, cancellation) {
            return from(clusters).pipe(mergeMap((cd) => {
                if (this._hasCluster(cd.key)) {
                    return of(this._getCluster(cd.key));
                }
                return this._getCluster$(cd.url, cd.key, cancellation)
                    .pipe(catchError((error) => {
                    if (error instanceof CancelMapillaryError) {
                        return empty();
                    }
                    console.error(error);
                    return empty();
                }));
            }, 6), filter(() => {
                return cellId in this._cellClusters;
            }), tap((reconstruction) => {
                if (!this._hasCluster(reconstruction.id)) {
                    this._clusters[reconstruction.id] = reconstruction;
                }
                if (!(reconstruction.id in this._clusterCells)) {
                    this._clusterCells[reconstruction.id] = [];
                }
                if (this._clusterCells[reconstruction.id].indexOf(cellId) === -1) {
                    this._clusterCells[reconstruction.id].push(cellId);
                }
            }));
        }
        _getCluster(id) {
            return this._clusters[id];
        }
        _getCluster$(url, clusterId, abort) {
            return Observable.create((subscriber) => {
                this._data.getCluster(url, abort)
                    .then((reconstruction) => {
                    reconstruction.id = clusterId;
                    subscriber.next(reconstruction);
                    subscriber.complete();
                }, (error) => {
                    subscriber.error(error);
                });
            });
        }
        _hasCluster(id) {
            return id in this._clusters;
        }
    }

    function connectedComponent(cellId, depth, geometry) {
        const cells = new Set();
        cells.add(cellId);
        connectedComponentRecursive(cells, [cellId], 0, depth, geometry);
        return Array.from(cells);
    }
    function connectedComponentRecursive(cells, current, currentDepth, maxDepth, geometry) {
        if (currentDepth >= maxDepth) {
            return;
        }
        const adjacent = [];
        for (const cellId of current) {
            const aCells = geometry.getAdjacent(cellId);
            adjacent.push(...aCells);
        }
        const newCells = [];
        for (const a of adjacent) {
            if (cells.has(a)) {
                continue;
            }
            cells.add(a);
            newCells.push(a);
        }
        connectedComponentRecursive(cells, newCells, currentDepth + 1, maxDepth, geometry);
    }

    class SpatialComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._cache = new SpatialCache(navigator.graphService, navigator.api.data);
            this._scene = new SpatialScene(this._getDefaultConfiguration());
            this._viewportCoords = new ViewportCoords();
            this._spatial = new Spatial();
        }
        /**
         * Returns the image id of the camera frame closest to the current
         * render camera position at the specified point.
         *
         * @description Notice that the pixelPoint argument requires x, y
         * coordinates from pixel space.
         *
         * With this function, you can use the coordinates provided by mouse
         * events to get information out of the spatial component.
         *
         * If no camera frame exist at the pixel
         * point, `null` will be returned.
         *
         * @param {Array<number>} pixelPoint - Pixel coordinates on
         * the viewer element.
         * @returns {string} Image id of the camera frame closest to
         * the camera. If no camera frame is intersected at the
         * pixel point, `null` will be returned.
         *
         * @example
         * ```js
         * spatialComponent.getFrameIdAt([100, 125])
         *     .then((imageId) => { console.log(imageId); });
         * ```
         */
        getFrameIdAt(pixelPoint) {
            return new Promise((resolve, reject) => {
                this._container.renderService.renderCamera$.pipe(first(), map((render) => {
                    const viewport = this._viewportCoords
                        .canvasToViewport(pixelPoint[0], pixelPoint[1], this._container.container);
                    const id = this._scene.intersection
                        .intersectObjects(viewport, render.perspective);
                    return id;
                }))
                    .subscribe((id) => {
                    resolve(id);
                }, (error) => {
                    reject(error);
                });
            });
        }
        _activate() {
            this._navigator.cacheService.configure({ cellDepth: 3 });
            const subs = this._subscriptions;
            subs.push(this._navigator.stateService.reference$
                .subscribe(() => {
                this._scene.uncache();
            }));
            subs.push(this._navigator.graphService.filter$
                .subscribe(imageFilter => { this._scene.setFilter(imageFilter); }));
            const bearing$ = this._container.renderService.bearing$.pipe(map((bearing) => {
                const interval = 6;
                const discrete = interval * Math.floor(bearing / interval);
                return discrete;
            }), distinctUntilChanged(), publishReplay(1), refCount());
            const cellId$ = this._navigator.stateService.currentImage$
                .pipe(map((image) => {
                return this._navigator.api.data.geometry
                    .lngLatToCellId(image.originalLngLat);
            }), distinctUntilChanged(), publishReplay(1), refCount());
            const cellGridDepth$ = this._configuration$
                .pipe(map((c) => {
                return this._spatial.clamp(c.cellGridDepth, 1, 3);
            }), distinctUntilChanged(), publishReplay(1), refCount());
            const sequencePlay$ = combineLatest(this._navigator.playService.playing$, this._navigator.playService.speed$).pipe(map(([playing, speed]) => {
                return playing && speed > PlayService.sequenceSpeed;
            }), distinctUntilChanged(), publishReplay(1), refCount());
            const isOverview$ = this._navigator.stateService.state$.pipe(map((state) => {
                return isOverviewState(state);
            }), distinctUntilChanged(), publishReplay(1), refCount());
            subs.push(isOverview$.subscribe((isOverview) => {
                this._scene.setNavigationState(isOverview);
            }));
            const cell$ = combineLatest(isOverview$, sequencePlay$, bearing$, cellGridDepth$, this._navigator.stateService.currentImage$)
                .pipe(distinctUntilChanged(([o1, s1, b1, d1, i1], [o2, s2, b2, d2, i2]) => {
                if (o1 !== o2) {
                    return false;
                }
                const isd = i1.id === i2.id && s1 === s2 && d1 === d2;
                if (o1) {
                    return isd;
                }
                return isd && b1 === b2;
            }), concatMap(([isOverview, sequencePlay, bearing, depth, image]) => {
                if (isOverview) {
                    const geometry = this._navigator.api.data.geometry;
                    const cellId = geometry
                        .lngLatToCellId(image.originalLngLat);
                    const cells = sequencePlay ?
                        [cellId] :
                        connectedComponent(cellId, depth, geometry);
                    return of(cells);
                }
                const fov = sequencePlay ? 30 : 90;
                return of(this._cellsInFov(image, bearing, fov));
            }), switchMap((cellIds) => {
                return from(cellIds).pipe(mergeMap((cellId) => {
                    const t$ = this._cache.hasCell(cellId) ?
                        of(this._cache.getCell(cellId)) :
                        this._cache.cacheCell$(cellId);
                    return t$.pipe(map((images) => ({ id: cellId, images })));
                }, 6));
            }));
            subs.push(cell$.pipe(withLatestFrom(this._navigator.stateService.reference$))
                .subscribe(([cell, reference]) => {
                if (this._scene.hasCell(cell.id)) {
                    return;
                }
                this._scene.addCell(this._cellToTopocentric(cell.id, reference), cell.id);
            }));
            subs.push(cell$.pipe(withLatestFrom(this._navigator.stateService.reference$))
                .subscribe(([cell, reference]) => {
                this._addSceneImages(cell, reference);
            }));
            subs.push(cell$.pipe(concatMap((cell) => {
                const cellId = cell.id;
                let reconstructions$;
                if (this._cache.hasClusters(cellId)) {
                    reconstructions$ = from(this._cache.getClusters(cellId));
                }
                else if (this._cache.isCachingClusters(cellId)) {
                    reconstructions$ = this._cache.cacheClusters$(cellId).pipe(last(null, {}), switchMap(() => {
                        return from(this._cache.getClusters(cellId));
                    }));
                }
                else if (this._cache.hasCell(cellId)) {
                    reconstructions$ = this._cache.cacheClusters$(cellId);
                }
                else {
                    reconstructions$ = empty();
                }
                return combineLatest(of(cellId), reconstructions$);
            }), withLatestFrom(this._navigator.stateService.reference$))
                .subscribe(([[cellId, reconstruction], reference]) => {
                if (this._scene
                    .hasCluster(reconstruction.id, cellId)) {
                    return;
                }
                this._scene.addCluster(reconstruction, this._computeTranslation(reconstruction, reference), cellId);
            }));
            subs.push(this._configuration$.pipe(map((c) => {
                c.cameraSize = this._spatial.clamp(c.cameraSize, 0.01, 1);
                c.pointSize = this._spatial.clamp(c.pointSize, 0.01, 1);
                return {
                    cameraSize: c.cameraSize,
                    cameraVisualizationMode: c.cameraVisualizationMode,
                    cellsVisible: c.cellsVisible,
                    originalPositionMode: c.originalPositionMode,
                    pointSize: c.pointSize,
                    pointsVisible: c.pointsVisible,
                };
            }), distinctUntilChanged((c1, c2) => {
                return c1.cameraSize === c2.cameraSize &&
                    c1.cameraVisualizationMode === c2.cameraVisualizationMode &&
                    c1.cellsVisible === c2.cellsVisible &&
                    c1.originalPositionMode === c2.originalPositionMode &&
                    c1.pointSize === c2.pointSize &&
                    c1.pointsVisible === c2.pointsVisible;
            }))
                .subscribe((c) => {
                this._scene.setCameraSize(c.cameraSize);
                this._scene.setPointSize(c.pointSize);
                this._scene.setPointVisibility(c.pointsVisible);
                this._scene.setCellVisibility(c.cellsVisible);
                const cvm = c.cameraVisualizationMode;
                this._scene.setCameraVisualizationMode(cvm);
                const opm = c.originalPositionMode;
                this._scene.setPositionMode(opm);
            }));
            subs.push(combineLatest(cellId$, cellGridDepth$)
                .subscribe(([cellId, depth]) => {
                const keepCells = connectedComponent(cellId, depth, this._navigator.api.data.geometry);
                this._scene.uncache(keepCells);
                this._cache.uncache(keepCells);
            }));
            subs.push(this._navigator.playService.playing$.pipe(switchMap((playing) => {
                return playing ?
                    empty() :
                    this._container.mouseService.dblClick$;
            }), withLatestFrom(this._container.renderService.renderCamera$), switchMap(([event, render]) => {
                const element = this._container.container;
                const [canvasX, canvasY] = this._viewportCoords
                    .canvasPosition(event, element);
                const viewport = this._viewportCoords.canvasToViewport(canvasX, canvasY, element);
                const id = this._scene.intersection
                    .intersectObjects(viewport, render.perspective);
                return !!id ?
                    this._navigator.moveTo$(id).pipe(catchError(() => {
                        return empty();
                    })) :
                    empty();
            }))
                .subscribe());
            const intersectChange$ = combineLatest(this._configuration$, this._navigator.stateService.state$).pipe(map(([c, state]) => {
                c.cameraSize = this._spatial.clamp(c.cameraSize, 0.01, 1);
                return {
                    size: c.cameraSize,
                    visible: isModeVisible(c.cameraVisualizationMode),
                    state,
                };
            }), distinctUntilChanged((c1, c2) => {
                return c1.size === c2.size &&
                    c1.visible === c2.visible &&
                    c1.state === c2.state;
            }));
            const mouseMove$ = this._container.mouseService.mouseMove$.pipe(publishReplay(1), refCount());
            subs.push(mouseMove$.subscribe());
            const mouseHover$ = merge(this._container.mouseService.mouseEnter$, this._container.mouseService.mouseLeave$, this._container.mouseService.windowBlur$);
            subs.push(combineLatest(this._navigator.playService.playing$, mouseHover$, isOverview$, this._navigator.graphService.filter$)
                .pipe(switchMap(([playing, mouseHover]) => {
                return !playing && mouseHover.type === "pointerenter" ?
                    combineLatest(concat(mouseMove$.pipe(take(1)), this._container.mouseService.mouseMove$), this._container.renderService.renderCamera$, intersectChange$) :
                    combineLatest(of(mouseHover), of(null), of(null));
            }))
                .subscribe(([event, render]) => {
                if (event.type !== "pointermove") {
                    this._scene.setHoveredImage(null);
                    return;
                }
                const element = this._container.container;
                const [canvasX, canvasY] = this._viewportCoords.canvasPosition(event, element);
                const viewport = this._viewportCoords.canvasToViewport(canvasX, canvasY, element);
                const key = this._scene.intersection
                    .intersectObjects(viewport, render.perspective);
                this._scene.setHoveredImage(key);
            }));
            subs.push(this._navigator.stateService.currentId$
                .subscribe((id) => {
                this._scene.setSelectedImage(id);
            }));
            subs.push(this._navigator.stateService.currentState$
                .pipe(map((frame) => {
                const scene = this._scene;
                return {
                    name: this._name,
                    renderer: {
                        frameId: frame.id,
                        needsRender: scene.needsRender,
                        render: scene.render.bind(scene),
                        pass: RenderPass.Opaque,
                    },
                };
            }))
                .subscribe(this._container.glRenderer.render$));
            const updatedCell$ = this._navigator.graphService.dataAdded$
                .pipe(filter((cellId) => {
                return this._cache.hasCell(cellId);
            }), mergeMap((cellId) => {
                return this._cache.updateCell$(cellId).pipe(map((images) => ({ id: cellId, images })), withLatestFrom(this._navigator.stateService.reference$));
            }), publish(), refCount());
            subs.push(updatedCell$
                .subscribe(([cell, reference]) => {
                this._addSceneImages(cell, reference);
            }));
            subs.push(updatedCell$
                .pipe(concatMap(([cell]) => {
                const cellId = cell.id;
                const cache = this._cache;
                let reconstructions$;
                if (cache.hasClusters(cellId)) {
                    reconstructions$ =
                        cache.updateClusters$(cellId);
                }
                else if (cache.isCachingClusters(cellId)) {
                    reconstructions$ = this._cache.cacheClusters$(cellId).pipe(last(null, {}), switchMap(() => {
                        return from(cache.updateClusters$(cellId));
                    }));
                }
                else {
                    reconstructions$ = empty();
                }
                return combineLatest(of(cellId), reconstructions$);
            }), withLatestFrom(this._navigator.stateService.reference$))
                .subscribe(([[cellId, reconstruction], reference]) => {
                if (this._scene.hasCluster(reconstruction.id, cellId)) {
                    return;
                }
                this._scene.addCluster(reconstruction, this._computeTranslation(reconstruction, reference), cellId);
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
            this._cache.uncache();
            this._scene.deactivate();
            this._navigator.cacheService.configure();
        }
        _getDefaultConfiguration() {
            return {
                cameraSize: 0.1,
                cameraVisualizationMode: exports.CameraVisualizationMode.Homogeneous,
                cellGridDepth: 1,
                originalPositionMode: exports.OriginalPositionMode.Hidden,
                pointSize: 0.1,
                pointsVisible: true,
                cellsVisible: false,
            };
        }
        _addSceneImages(cell, reference) {
            const cellId = cell.id;
            const images = cell.images;
            for (const image of images) {
                if (this._scene.hasImage(image.id, cellId)) {
                    continue;
                }
                this._scene.addImage(image, this._createTransform(image, reference), this._computeOriginalPosition(image, reference), cellId);
            }
        }
        _cellsInFov(image, bearing, fov) {
            const spatial = this._spatial;
            const geometry = this._navigator.api.data.geometry;
            const cell = geometry.lngLatToCellId(image.originalLngLat);
            const cells = [cell];
            const threshold = fov / 2;
            const adjacent = geometry.getAdjacent(cell);
            for (const a of adjacent) {
                const vertices = geometry.getVertices(a);
                for (const vertex of vertices) {
                    const [x, y] = geodeticToEnu(vertex.lng, vertex.lat, 0, image.lngLat.lng, image.lngLat.lat, 0);
                    const azimuthal = Math.atan2(y, x);
                    const vertexBearing = spatial.radToDeg(spatial.azimuthalToBearing(azimuthal));
                    if (Math.abs(vertexBearing - bearing) < threshold) {
                        cells.push(a);
                    }
                }
            }
            return cells;
        }
        _computeOriginalPosition(image, reference) {
            return geodeticToEnu(image.originalLngLat.lng, image.originalLngLat.lat, image.originalAltitude != null ? image.originalAltitude : image.computedAltitude, reference.lng, reference.lat, reference.alt);
        }
        _cellToTopocentric(cellId, reference) {
            const vertices = this._navigator.api.data.geometry
                .getVertices(cellId)
                .map((vertex) => {
                return geodeticToEnu(vertex.lng, vertex.lat, -2, reference.lng, reference.lat, reference.alt);
            });
            return vertices;
        }
        _computeTranslation(reconstruction, reference) {
            return geodeticToEnu(reconstruction.reference.lng, reconstruction.reference.lat, reconstruction.reference.alt, reference.lng, reference.lat, reference.alt);
        }
        _createTransform(image, reference) {
            const translation = computeTranslation({ alt: image.computedAltitude, lat: image.lngLat.lat, lng: image.lngLat.lng }, image.rotation, reference);
            const transform = new Transform(image.exifOrientation, image.width, image.height, image.scale, image.rotation, translation, undefined, undefined, image.cameraParameters, image.cameraType);
            return transform;
        }
    }
    SpatialComponent.componentName = "spatial";

    /**
     * @class Geometry
     * @abstract
     * @classdesc Represents a geometry.
     */
    class Geometry {
        /**
         * Create a geometry.
         *
         * @constructor
         * @ignore
         */
        constructor() {
            this._notifyChanged$ = new Subject();
        }
        /**
         * Get changed observable.
         *
         * @description Emits the geometry itself every time the geometry
         * has changed.
         *
         * @returns {Observable<Geometry>} Observable emitting the geometry instance.
         * @ignore
         */
        get changed$() {
            return this._notifyChanged$;
        }
    }

    class GeometryTagError extends MapillaryError {
        constructor(message) {
            super(message != null ? message : "The provided geometry value is incorrect");
            Object.setPrototypeOf(this, GeometryTagError.prototype);
            this.name = "GeometryTagError";
        }
    }

    /**
     * @class PointsGeometry
     *
     * @classdesc Represents a point set in the 2D basic image coordinate system.
     *
     * @example
     * ```js
     * var points = [[0.5, 0.3], [0.7, 0.3], [0.6, 0.5]];
     * var pointsGeometry = new PointsGeometry(points);
     * ```
     */
    class PointsGeometry extends Geometry {
        /**
         * Create a points geometry.
         *
         * @constructor
         * @param {Array<Array<number>>} points - Array of 2D points on the basic coordinate
         * system. The number of points must be greater than or equal to two.
         *
         * @throws {GeometryTagError} Point coordinates must be valid basic coordinates.
         */
        constructor(points) {
            super();
            const pointsLength = points.length;
            if (pointsLength < 2) {
                throw new GeometryTagError("A points geometry must have two or more positions.");
            }
            this._points = [];
            for (const point of points) {
                if (point[0] < 0 || point[0] > 1 ||
                    point[1] < 0 || point[1] > 1) {
                    throw new GeometryTagError("Basic coordinates of points must be on the interval [0, 1].");
                }
                this._points.push(point.slice());
            }
        }
        /**
         * Get points property.
         * @returns {Array<Array<number>>} Array of 2d points.
         */
        get points() {
            return this._points;
        }
        /**
         * Add a point to the point set.
         *
         * @param {Array<number>} point - Point to add.
         * @ignore
         */
        addPoint2d(point) {
            const clamped = [
                Math.max(0, Math.min(1, point[0])),
                Math.max(0, Math.min(1, point[1])),
            ];
            this._points.push(clamped);
            this._notifyChanged$.next(this);
        }
        /**
         * Get the coordinates of a point from the point set representation of the geometry.
         *
         * @param {number} index - Point index.
         * @returns {Array<number>} Array representing the 2D basic coordinates of the point.
         * @ignore
         */
        getPoint2d(index) {
            return this._points[index].slice();
        }
        /**
         * Remove a point from the point set.
         *
         * @param {number} index - The index of the point to remove.
         * @ignore
         */
        removePoint2d(index) {
            if (index < 0 ||
                index >= this._points.length ||
                this._points.length < 3) {
                throw new GeometryTagError("Index for removed point must be valid.");
            }
            this._points.splice(index, 1);
            this._notifyChanged$.next(this);
        }
        /** @ignore */
        setVertex2d(index, value, transform) {
            this.setPoint2d(index, value, transform);
        }
        /** @ignore */
        setPoint2d(index, value, transform) {
            const changed = [
                Math.max(0, Math.min(1, value[0])),
                Math.max(0, Math.min(1, value[1])),
            ];
            this._points[index] = changed;
            this._notifyChanged$.next(this);
        }
        /** @ignore */
        getPoints3d(transform) {
            return this._getPoints3d(this._points, transform);
        }
        /** @ignore */
        getPoint3d(index, transform) {
            return transform.unprojectBasic(this._points[index], 200);
        }
        /** @ignore */
        getPoints2d() {
            return this._points.slice();
        }
        /** @ignore */
        getCentroid2d(transform) {
            if (!transform) {
                throw new GeometryTagError("Get centroid must be called with a transform for points geometries.");
            }
            const [minX, minY, maxX, maxY] = this.getRect2d(transform);
            const centroidX = minX < maxX ?
                (minX + maxX) / 2 :
                ((minX + maxX + 1) / 2) % 1;
            const centroidY = (minY + maxY) / 2;
            return [centroidX, centroidY];
        }
        /** @ignore */
        getCentroid3d(transform) {
            let centroid2d = this.getCentroid2d();
            return transform.unprojectBasic(centroid2d, 200);
        }
        /** @ignore */
        getRect2d(transform) {
            let minX = 1;
            let maxX = 0;
            let minY = 1;
            let maxY = 0;
            const points = this._points;
            for (const point of points) {
                if (point[0] < minX) {
                    minX = point[0];
                }
                if (point[0] > maxX) {
                    maxX = point[0];
                }
                if (point[1] < minY) {
                    minY = point[1];
                }
                if (point[1] > maxY) {
                    maxY = point[1];
                }
            }
            if (isSpherical(transform.cameraType)) {
                const indices = [];
                for (let i = 0; i < points.length; i++) {
                    indices[i] = i;
                }
                indices.sort((a, b) => {
                    return points[a][0] < points[b][0] ?
                        -1 :
                        points[a][0] > points[b][0] ?
                            1 :
                            a < b ? -1 : 1;
                });
                let maxDistanceX = points[indices[0]][0] + 1 - points[indices[indices.length - 1]][0];
                let leftMostIndex = 0;
                for (let i = 0; i < indices.length - 1; i++) {
                    const index1 = indices[i];
                    const index2 = indices[i + 1];
                    const distanceX = points[index2][0] - points[index1][0];
                    if (distanceX > maxDistanceX) {
                        maxDistanceX = distanceX;
                        leftMostIndex = i + 1;
                    }
                }
                if (leftMostIndex > 0) {
                    minX = points[indices[leftMostIndex]][0];
                    maxX = points[indices[leftMostIndex - 1]][0];
                }
            }
            return [minX, minY, maxX, maxY];
        }
        /** @ignore */
        setCentroid2d(value, transform) {
            throw new Error("Not implemented");
        }
        _getPoints3d(points2d, transform) {
            return points2d
                .map((point) => {
                return transform.unprojectBasic(point, 200);
            });
        }
    }

    class CreateTag {
        constructor(geometry, transform, viewportCoords) {
            this._geometry = geometry;
            this._transform = transform;
            this._viewportCoords = !!viewportCoords ? viewportCoords : new ViewportCoords();
            this._aborted$ = new Subject();
            this._created$ = new Subject();
            this._glObjectsChanged$ = new Subject();
            this._geometryChangedSubscription = this._geometry.changed$
                .subscribe(() => {
                this._onGeometryChanged();
                this._glObjectsChanged$.next(this);
            });
        }
        get geometry() {
            return this._geometry;
        }
        get glObjects() {
            return this._glObjects;
        }
        get aborted$() {
            return this._aborted$;
        }
        get created$() {
            return this._created$;
        }
        get glObjectsChanged$() {
            return this._glObjectsChanged$;
        }
        get geometryChanged$() {
            return this._geometry.changed$.pipe(map(() => {
                return this;
            }));
        }
        dispose() {
            this._geometryChangedSubscription.unsubscribe();
        }
        _canvasToTransform(canvas) {
            const canvasX = Math.round(canvas[0]);
            const canvasY = Math.round(canvas[1]);
            const transform = `translate(-50%,-50%) translate(${canvasX}px,${canvasY}px)`;
            return transform;
        }
        _colorToBackground(color) {
            return "#" + ("000000" + color.toString(16)).substr(-6);
        }
        _createOutine(polygon3d, color) {
            const positions = this._getLinePositions(polygon3d);
            const geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            const material = new LineBasicMaterial({
                color: color,
                linewidth: 1,
            });
            return new Line(geometry, material);
        }
        _disposeLine(line) {
            if (line == null) {
                return;
            }
            line.geometry.dispose();
            line.material.dispose();
        }
        _getLinePositions(polygon3d) {
            const length = polygon3d.length;
            const positions = new Float32Array(length * 3);
            for (let i = 0; i < length; ++i) {
                const index = 3 * i;
                const position = polygon3d[i];
                positions[index] = position[0];
                positions[index + 1] = position[1];
                positions[index + 2] = position[2];
            }
            return positions;
        }
    }

    var earcut_1 = earcut;
    var _default$2 = earcut;

    function earcut(data, holeIndices, dim) {

        dim = dim || 2;

        var hasHoles = holeIndices && holeIndices.length,
            outerLen = hasHoles ? holeIndices[0] * dim : data.length,
            outerNode = linkedList(data, 0, outerLen, dim, true),
            triangles = [];

        if (!outerNode || outerNode.next === outerNode.prev) return triangles;

        var minX, minY, maxX, maxY, x, y, invSize;

        if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);

        // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
        if (data.length > 80 * dim) {
            minX = maxX = data[0];
            minY = maxY = data[1];

            for (var i = dim; i < outerLen; i += dim) {
                x = data[i];
                y = data[i + 1];
                if (x < minX) minX = x;
                if (y < minY) minY = y;
                if (x > maxX) maxX = x;
                if (y > maxY) maxY = y;
            }

            // minX, minY and invSize are later used to transform coords into integers for z-order calculation
            invSize = Math.max(maxX - minX, maxY - minY);
            invSize = invSize !== 0 ? 1 / invSize : 0;
        }

        earcutLinked(outerNode, triangles, dim, minX, minY, invSize);

        return triangles;
    }

    // create a circular doubly linked list from polygon points in the specified winding order
    function linkedList(data, start, end, dim, clockwise) {
        var i, last;

        if (clockwise === (signedArea$1(data, start, end, dim) > 0)) {
            for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
        } else {
            for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
        }

        if (last && equals$1(last, last.next)) {
            removeNode(last);
            last = last.next;
        }

        return last;
    }

    // eliminate colinear or duplicate points
    function filterPoints(start, end) {
        if (!start) return start;
        if (!end) end = start;

        var p = start,
            again;
        do {
            again = false;

            if (!p.steiner && (equals$1(p, p.next) || area(p.prev, p, p.next) === 0)) {
                removeNode(p);
                p = end = p.prev;
                if (p === p.next) break;
                again = true;

            } else {
                p = p.next;
            }
        } while (again || p !== end);

        return end;
    }

    // main ear slicing loop which triangulates a polygon (given as a linked list)
    function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
        if (!ear) return;

        // interlink polygon nodes in z-order
        if (!pass && invSize) indexCurve(ear, minX, minY, invSize);

        var stop = ear,
            prev, next;

        // iterate through ears, slicing them one by one
        while (ear.prev !== ear.next) {
            prev = ear.prev;
            next = ear.next;

            if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
                // cut off the triangle
                triangles.push(prev.i / dim);
                triangles.push(ear.i / dim);
                triangles.push(next.i / dim);

                removeNode(ear);

                // skipping the next vertex leads to less sliver triangles
                ear = next.next;
                stop = next.next;

                continue;
            }

            ear = next;

            // if we looped through the whole remaining polygon and can't find any more ears
            if (ear === stop) {
                // try filtering points and slicing again
                if (!pass) {
                    earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);

                // if this didn't work, try curing all small self-intersections locally
                } else if (pass === 1) {
                    ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
                    earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);

                // as a last resort, try splitting the remaining polygon into two
                } else if (pass === 2) {
                    splitEarcut(ear, triangles, dim, minX, minY, invSize);
                }

                break;
            }
        }
    }

    // check whether a polygon node forms a valid ear with adjacent nodes
    function isEar(ear) {
        var a = ear.prev,
            b = ear,
            c = ear.next;

        if (area(a, b, c) >= 0) return false; // reflex, can't be an ear

        // now make sure we don't have other points inside the potential ear
        var p = ear.next.next;

        while (p !== ear.prev) {
            if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
                area(p.prev, p, p.next) >= 0) return false;
            p = p.next;
        }

        return true;
    }

    function isEarHashed(ear, minX, minY, invSize) {
        var a = ear.prev,
            b = ear,
            c = ear.next;

        if (area(a, b, c) >= 0) return false; // reflex, can't be an ear

        // triangle bbox; min & max are calculated like this for speed
        var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x),
            minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y),
            maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x),
            maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y);

        // z-order range for the current triangle bbox;
        var minZ = zOrder(minTX, minTY, minX, minY, invSize),
            maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);

        var p = ear.prevZ,
            n = ear.nextZ;

        // look for points inside the triangle in both directions
        while (p && p.z >= minZ && n && n.z <= maxZ) {
            if (p !== ear.prev && p !== ear.next &&
                pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
                area(p.prev, p, p.next) >= 0) return false;
            p = p.prevZ;

            if (n !== ear.prev && n !== ear.next &&
                pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
                area(n.prev, n, n.next) >= 0) return false;
            n = n.nextZ;
        }

        // look for remaining points in decreasing z-order
        while (p && p.z >= minZ) {
            if (p !== ear.prev && p !== ear.next &&
                pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
                area(p.prev, p, p.next) >= 0) return false;
            p = p.prevZ;
        }

        // look for remaining points in increasing z-order
        while (n && n.z <= maxZ) {
            if (n !== ear.prev && n !== ear.next &&
                pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
                area(n.prev, n, n.next) >= 0) return false;
            n = n.nextZ;
        }

        return true;
    }

    // go through all polygon nodes and cure small local self-intersections
    function cureLocalIntersections(start, triangles, dim) {
        var p = start;
        do {
            var a = p.prev,
                b = p.next.next;

            if (!equals$1(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {

                triangles.push(a.i / dim);
                triangles.push(p.i / dim);
                triangles.push(b.i / dim);

                // remove two nodes involved
                removeNode(p);
                removeNode(p.next);

                p = start = b;
            }
            p = p.next;
        } while (p !== start);

        return filterPoints(p);
    }

    // try splitting polygon into two and triangulate them independently
    function splitEarcut(start, triangles, dim, minX, minY, invSize) {
        // look for a valid diagonal that divides the polygon into two
        var a = start;
        do {
            var b = a.next.next;
            while (b !== a.prev) {
                if (a.i !== b.i && isValidDiagonal(a, b)) {
                    // split the polygon in two by the diagonal
                    var c = splitPolygon(a, b);

                    // filter colinear points around the cuts
                    a = filterPoints(a, a.next);
                    c = filterPoints(c, c.next);

                    // run earcut on each half
                    earcutLinked(a, triangles, dim, minX, minY, invSize);
                    earcutLinked(c, triangles, dim, minX, minY, invSize);
                    return;
                }
                b = b.next;
            }
            a = a.next;
        } while (a !== start);
    }

    // link every hole into the outer loop, producing a single-ring polygon without holes
    function eliminateHoles(data, holeIndices, outerNode, dim) {
        var queue = [],
            i, len, start, end, list;

        for (i = 0, len = holeIndices.length; i < len; i++) {
            start = holeIndices[i] * dim;
            end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
            list = linkedList(data, start, end, dim, false);
            if (list === list.next) list.steiner = true;
            queue.push(getLeftmost(list));
        }

        queue.sort(compareX);

        // process holes from left to right
        for (i = 0; i < queue.length; i++) {
            eliminateHole(queue[i], outerNode);
            outerNode = filterPoints(outerNode, outerNode.next);
        }

        return outerNode;
    }

    function compareX(a, b) {
        return a.x - b.x;
    }

    // find a bridge between vertices that connects hole with an outer ring and and link it
    function eliminateHole(hole, outerNode) {
        outerNode = findHoleBridge(hole, outerNode);
        if (outerNode) {
            var b = splitPolygon(outerNode, hole);

            // filter collinear points around the cuts
            filterPoints(outerNode, outerNode.next);
            filterPoints(b, b.next);
        }
    }

    // David Eberly's algorithm for finding a bridge between hole and outer polygon
    function findHoleBridge(hole, outerNode) {
        var p = outerNode,
            hx = hole.x,
            hy = hole.y,
            qx = -Infinity,
            m;

        // find a segment intersected by a ray from the hole's leftmost point to the left;
        // segment's endpoint with lesser x will be potential connection point
        do {
            if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
                var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
                if (x <= hx && x > qx) {
                    qx = x;
                    if (x === hx) {
                        if (hy === p.y) return p;
                        if (hy === p.next.y) return p.next;
                    }
                    m = p.x < p.next.x ? p : p.next;
                }
            }
            p = p.next;
        } while (p !== outerNode);

        if (!m) return null;

        if (hx === qx) return m; // hole touches outer segment; pick leftmost endpoint

        // look for points inside the triangle of hole point, segment intersection and endpoint;
        // if there are no points found, we have a valid connection;
        // otherwise choose the point of the minimum angle with the ray as connection point

        var stop = m,
            mx = m.x,
            my = m.y,
            tanMin = Infinity,
            tan;

        p = m;

        do {
            if (hx >= p.x && p.x >= mx && hx !== p.x &&
                    pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {

                tan = Math.abs(hy - p.y) / (hx - p.x); // tangential

                if (locallyInside(p, hole) &&
                    (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
                    m = p;
                    tanMin = tan;
                }
            }

            p = p.next;
        } while (p !== stop);

        return m;
    }

    // whether sector in vertex m contains sector in vertex p in the same coordinates
    function sectorContainsSector(m, p) {
        return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
    }

    // interlink polygon nodes in z-order
    function indexCurve(start, minX, minY, invSize) {
        var p = start;
        do {
            if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize);
            p.prevZ = p.prev;
            p.nextZ = p.next;
            p = p.next;
        } while (p !== start);

        p.prevZ.nextZ = null;
        p.prevZ = null;

        sortLinked(p);
    }

    // Simon Tatham's linked list merge sort algorithm
    // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
    function sortLinked(list) {
        var i, p, q, e, tail, numMerges, pSize, qSize,
            inSize = 1;

        do {
            p = list;
            list = null;
            tail = null;
            numMerges = 0;

            while (p) {
                numMerges++;
                q = p;
                pSize = 0;
                for (i = 0; i < inSize; i++) {
                    pSize++;
                    q = q.nextZ;
                    if (!q) break;
                }
                qSize = inSize;

                while (pSize > 0 || (qSize > 0 && q)) {

                    if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
                        e = p;
                        p = p.nextZ;
                        pSize--;
                    } else {
                        e = q;
                        q = q.nextZ;
                        qSize--;
                    }

                    if (tail) tail.nextZ = e;
                    else list = e;

                    e.prevZ = tail;
                    tail = e;
                }

                p = q;
            }

            tail.nextZ = null;
            inSize *= 2;

        } while (numMerges > 1);

        return list;
    }

    // z-order of a point given coords and inverse of the longer side of data bbox
    function zOrder(x, y, minX, minY, invSize) {
        // coords are transformed into non-negative 15-bit integer range
        x = 32767 * (x - minX) * invSize;
        y = 32767 * (y - minY) * invSize;

        x = (x | (x << 8)) & 0x00FF00FF;
        x = (x | (x << 4)) & 0x0F0F0F0F;
        x = (x | (x << 2)) & 0x33333333;
        x = (x | (x << 1)) & 0x55555555;

        y = (y | (y << 8)) & 0x00FF00FF;
        y = (y | (y << 4)) & 0x0F0F0F0F;
        y = (y | (y << 2)) & 0x33333333;
        y = (y | (y << 1)) & 0x55555555;

        return x | (y << 1);
    }

    // find the leftmost node of a polygon ring
    function getLeftmost(start) {
        var p = start,
            leftmost = start;
        do {
            if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p;
            p = p.next;
        } while (p !== start);

        return leftmost;
    }

    // check if a point lies within a convex triangle
    function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
        return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
               (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
               (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
    }

    // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
    function isValidDiagonal(a, b) {
        return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
               (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
                (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
                equals$1(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
    }

    // signed area of a triangle
    function area(p, q, r) {
        return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
    }

    // check if two points are equal
    function equals$1(p1, p2) {
        return p1.x === p2.x && p1.y === p2.y;
    }

    // check if two segments intersect
    function intersects(p1, q1, p2, q2) {
        var o1 = sign(area(p1, q1, p2));
        var o2 = sign(area(p1, q1, q2));
        var o3 = sign(area(p2, q2, p1));
        var o4 = sign(area(p2, q2, q1));

        if (o1 !== o2 && o3 !== o4) return true; // general case

        if (o1 === 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
        if (o2 === 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
        if (o3 === 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
        if (o4 === 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2

        return false;
    }

    // for collinear points p, q, r, check if point q lies on segment pr
    function onSegment(p, q, r) {
        return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
    }

    function sign(num) {
        return num > 0 ? 1 : num < 0 ? -1 : 0;
    }

    // check if a polygon diagonal intersects any polygon segments
    function intersectsPolygon(a, b) {
        var p = a;
        do {
            if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
                    intersects(p, p.next, a, b)) return true;
            p = p.next;
        } while (p !== a);

        return false;
    }

    // check if a polygon diagonal is locally inside the polygon
    function locallyInside(a, b) {
        return area(a.prev, a, a.next) < 0 ?
            area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
            area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
    }

    // check if the middle point of a polygon diagonal is inside the polygon
    function middleInside(a, b) {
        var p = a,
            inside = false,
            px = (a.x + b.x) / 2,
            py = (a.y + b.y) / 2;
        do {
            if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
                    (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
                inside = !inside;
            p = p.next;
        } while (p !== a);

        return inside;
    }

    // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
    // if one belongs to the outer ring and another to a hole, it merges it into a single ring
    function splitPolygon(a, b) {
        var a2 = new Node(a.i, a.x, a.y),
            b2 = new Node(b.i, b.x, b.y),
            an = a.next,
            bp = b.prev;

        a.next = b;
        b.prev = a;

        a2.next = an;
        an.prev = a2;

        b2.next = a2;
        a2.prev = b2;

        bp.next = b2;
        b2.prev = bp;

        return b2;
    }

    // create a node and optionally link it with previous one (in a circular doubly linked list)
    function insertNode(i, x, y, last) {
        var p = new Node(i, x, y);

        if (!last) {
            p.prev = p;
            p.next = p;

        } else {
            p.next = last.next;
            p.prev = last;
            last.next.prev = p;
            last.next = p;
        }
        return p;
    }

    function removeNode(p) {
        p.next.prev = p.prev;
        p.prev.next = p.next;

        if (p.prevZ) p.prevZ.nextZ = p.nextZ;
        if (p.nextZ) p.nextZ.prevZ = p.prevZ;
    }

    function Node(i, x, y) {
        // vertex index in coordinates array
        this.i = i;

        // vertex coordinates
        this.x = x;
        this.y = y;

        // previous and next vertex nodes in a polygon ring
        this.prev = null;
        this.next = null;

        // z-order curve value
        this.z = null;

        // previous and next nodes in z-order
        this.prevZ = null;
        this.nextZ = null;

        // indicates whether this is a steiner point
        this.steiner = false;
    }

    // return a percentage difference between the polygon area and its triangulation area;
    // used to verify correctness of triangulation
    earcut.deviation = function (data, holeIndices, dim, triangles) {
        var hasHoles = holeIndices && holeIndices.length;
        var outerLen = hasHoles ? holeIndices[0] * dim : data.length;

        var polygonArea = Math.abs(signedArea$1(data, 0, outerLen, dim));
        if (hasHoles) {
            for (var i = 0, len = holeIndices.length; i < len; i++) {
                var start = holeIndices[i] * dim;
                var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
                polygonArea -= Math.abs(signedArea$1(data, start, end, dim));
            }
        }

        var trianglesArea = 0;
        for (i = 0; i < triangles.length; i += 3) {
            var a = triangles[i] * dim;
            var b = triangles[i + 1] * dim;
            var c = triangles[i + 2] * dim;
            trianglesArea += Math.abs(
                (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
                (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
        }

        return polygonArea === 0 && trianglesArea === 0 ? 0 :
            Math.abs((trianglesArea - polygonArea) / polygonArea);
    };

    function signedArea$1(data, start, end, dim) {
        var sum = 0;
        for (var i = start, j = end - dim; i < end; i += dim) {
            sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
            j = i;
        }
        return sum;
    }

    // turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
    earcut.flatten = function (data) {
        var dim = data[0][0].length,
            result = {vertices: [], holes: [], dimensions: dim},
            holeIndex = 0;

        for (var i = 0; i < data.length; i++) {
            for (var j = 0; j < data[i].length; j++) {
                for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);
            }
            if (i > 0) {
                holeIndex += data[i - 1].length;
                result.holes.push(holeIndex);
            }
        }
        return result;
    };
    earcut_1.default = _default$2;

    class TinyQueue$1 {
        constructor(data = [], compare = defaultCompare$1) {
            this.data = data;
            this.length = this.data.length;
            this.compare = compare;

            if (this.length > 0) {
                for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
            }
        }

        push(item) {
            this.data.push(item);
            this.length++;
            this._up(this.length - 1);
        }

        pop() {
            if (this.length === 0) return undefined;

            const top = this.data[0];
            const bottom = this.data.pop();
            this.length--;

            if (this.length > 0) {
                this.data[0] = bottom;
                this._down(0);
            }

            return top;
        }

        peek() {
            return this.data[0];
        }

        _up(pos) {
            const {data, compare} = this;
            const item = data[pos];

            while (pos > 0) {
                const parent = (pos - 1) >> 1;
                const current = data[parent];
                if (compare(item, current) >= 0) break;
                data[pos] = current;
                pos = parent;
            }

            data[pos] = item;
        }

        _down(pos) {
            const {data, compare} = this;
            const halfLength = this.length >> 1;
            const item = data[pos];

            while (pos < halfLength) {
                let left = (pos << 1) + 1;
                let best = data[left];
                const right = left + 1;

                if (right < this.length && compare(data[right], best) < 0) {
                    left = right;
                    best = data[right];
                }
                if (compare(best, item) >= 0) break;

                data[pos] = best;
                pos = left;
            }

            data[pos] = item;
        }
    }

    function defaultCompare$1(a, b) {
        return a < b ? -1 : a > b ? 1 : 0;
    }

    var tinyqueue$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        'default': TinyQueue$1
    });

    var require$$0 = /*@__PURE__*/getAugmentedNamespace(tinyqueue$1);

    var Queue = require$$0;

    if (Queue.default) Queue = Queue.default; // temporary webpack fix

    var polylabel_1 = polylabel;
    var _default$1 = polylabel;

    function polylabel(polygon, precision, debug) {
        precision = precision || 1.0;

        // find the bounding box of the outer ring
        var minX, minY, maxX, maxY;
        for (var i = 0; i < polygon[0].length; i++) {
            var p = polygon[0][i];
            if (!i || p[0] < minX) minX = p[0];
            if (!i || p[1] < minY) minY = p[1];
            if (!i || p[0] > maxX) maxX = p[0];
            if (!i || p[1] > maxY) maxY = p[1];
        }

        var width = maxX - minX;
        var height = maxY - minY;
        var cellSize = Math.min(width, height);
        var h = cellSize / 2;

        if (cellSize === 0) {
            var degeneratePoleOfInaccessibility = [minX, minY];
            degeneratePoleOfInaccessibility.distance = 0;
            return degeneratePoleOfInaccessibility;
        }

        // a priority queue of cells in order of their "potential" (max distance to polygon)
        var cellQueue = new Queue(undefined, compareMax);

        // cover polygon with initial cells
        for (var x = minX; x < maxX; x += cellSize) {
            for (var y = minY; y < maxY; y += cellSize) {
                cellQueue.push(new Cell(x + h, y + h, h, polygon));
            }
        }

        // take centroid as the first best guess
        var bestCell = getCentroidCell(polygon);

        // special case for rectangular polygons
        var bboxCell = new Cell(minX + width / 2, minY + height / 2, 0, polygon);
        if (bboxCell.d > bestCell.d) bestCell = bboxCell;

        var numProbes = cellQueue.length;

        while (cellQueue.length) {
            // pick the most promising cell from the queue
            var cell = cellQueue.pop();

            // update the best cell if we found a better one
            if (cell.d > bestCell.d) {
                bestCell = cell;
                if (debug) console.log('found best %d after %d probes', Math.round(1e4 * cell.d) / 1e4, numProbes);
            }

            // do not drill down further if there's no chance of a better solution
            if (cell.max - bestCell.d <= precision) continue;

            // split the cell into four cells
            h = cell.h / 2;
            cellQueue.push(new Cell(cell.x - h, cell.y - h, h, polygon));
            cellQueue.push(new Cell(cell.x + h, cell.y - h, h, polygon));
            cellQueue.push(new Cell(cell.x - h, cell.y + h, h, polygon));
            cellQueue.push(new Cell(cell.x + h, cell.y + h, h, polygon));
            numProbes += 4;
        }

        if (debug) {
            console.log('num probes: ' + numProbes);
            console.log('best distance: ' + bestCell.d);
        }

        var poleOfInaccessibility = [bestCell.x, bestCell.y];
        poleOfInaccessibility.distance = bestCell.d;
        return poleOfInaccessibility;
    }

    function compareMax(a, b) {
        return b.max - a.max;
    }

    function Cell(x, y, h, polygon) {
        this.x = x; // cell center x
        this.y = y; // cell center y
        this.h = h; // half the cell size
        this.d = pointToPolygonDist(x, y, polygon); // distance from cell center to polygon
        this.max = this.d + this.h * Math.SQRT2; // max distance to polygon within a cell
    }

    // signed distance from point to polygon outline (negative if point is outside)
    function pointToPolygonDist(x, y, polygon) {
        var inside = false;
        var minDistSq = Infinity;

        for (var k = 0; k < polygon.length; k++) {
            var ring = polygon[k];

            for (var i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
                var a = ring[i];
                var b = ring[j];

                if ((a[1] > y !== b[1] > y) &&
                    (x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0])) inside = !inside;

                minDistSq = Math.min(minDistSq, getSegDistSq(x, y, a, b));
            }
        }

        return minDistSq === 0 ? 0 : (inside ? 1 : -1) * Math.sqrt(minDistSq);
    }

    // get polygon centroid
    function getCentroidCell(polygon) {
        var area = 0;
        var x = 0;
        var y = 0;
        var points = polygon[0];

        for (var i = 0, len = points.length, j = len - 1; i < len; j = i++) {
            var a = points[i];
            var b = points[j];
            var f = a[0] * b[1] - b[0] * a[1];
            x += (a[0] + b[0]) * f;
            y += (a[1] + b[1]) * f;
            area += f * 3;
        }
        if (area === 0) return new Cell(points[0][0], points[0][1], 0, polygon);
        return new Cell(x / area, y / area, 0, polygon);
    }

    // get squared distance from a point to a segment
    function getSegDistSq(px, py, a, b) {

        var x = a[0];
        var y = a[1];
        var dx = b[0] - x;
        var dy = b[1] - y;

        if (dx !== 0 || dy !== 0) {

            var t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);

            if (t > 1) {
                x = b[0];
                y = b[1];

            } else if (t > 0) {
                x += dx * t;
                y += dy * t;
            }
        }

        dx = px - x;
        dy = py - y;

        return dx * dx + dy * dy;
    }
    polylabel_1.default = _default$1;

    function DEFAULT_COMPARE (a, b) { return a > b ? 1 : a < b ? -1 : 0; }

    class SplayTree {

      constructor(compare = DEFAULT_COMPARE, noDuplicates = false) {
        this._compare = compare;
        this._root = null;
        this._size = 0;
        this._noDuplicates = !!noDuplicates;
      }


      rotateLeft(x) {
        var y = x.right;
        if (y) {
          x.right = y.left;
          if (y.left) y.left.parent = x;
          y.parent = x.parent;
        }

        if (!x.parent)                this._root = y;
        else if (x === x.parent.left) x.parent.left = y;
        else                          x.parent.right = y;
        if (y) y.left = x;
        x.parent = y;
      }


      rotateRight(x) {
        var y = x.left;
        if (y) {
          x.left = y.right;
          if (y.right) y.right.parent = x;
          y.parent = x.parent;
        }

        if (!x.parent)               this._root = y;
        else if(x === x.parent.left) x.parent.left = y;
        else                         x.parent.right = y;
        if (y) y.right = x;
        x.parent = y;
      }


      _splay(x) {
        while (x.parent) {
          var p = x.parent;
          if (!p.parent) {
            if (p.left === x) this.rotateRight(p);
            else              this.rotateLeft(p);
          } else if (p.left === x && p.parent.left === p) {
            this.rotateRight(p.parent);
            this.rotateRight(p);
          } else if (p.right === x && p.parent.right === p) {
            this.rotateLeft(p.parent);
            this.rotateLeft(p);
          } else if (p.left === x && p.parent.right === p) {
            this.rotateRight(p);
            this.rotateLeft(p);
          } else {
            this.rotateLeft(p);
            this.rotateRight(p);
          }
        }
      }


      splay(x) {
        var p, gp, ggp, l, r;

        while (x.parent) {
          p = x.parent;
          gp = p.parent;

          if (gp && gp.parent) {
            ggp = gp.parent;
            if (ggp.left === gp) ggp.left  = x;
            else                 ggp.right = x;
            x.parent = ggp;
          } else {
            x.parent = null;
            this._root = x;
          }

          l = x.left; r = x.right;

          if (x === p.left) { // left
            if (gp) {
              if (gp.left === p) {
                /* zig-zig */
                if (p.right) {
                  gp.left = p.right;
                  gp.left.parent = gp;
                } else gp.left = null;

                p.right   = gp;
                gp.parent = p;
              } else {
                /* zig-zag */
                if (l) {
                  gp.right = l;
                  l.parent = gp;
                } else gp.right = null;

                x.left    = gp;
                gp.parent = x;
              }
            }
            if (r) {
              p.left = r;
              r.parent = p;
            } else p.left = null;

            x.right  = p;
            p.parent = x;
          } else { // right
            if (gp) {
              if (gp.right === p) {
                /* zig-zig */
                if (p.left) {
                  gp.right = p.left;
                  gp.right.parent = gp;
                } else gp.right = null;

                p.left = gp;
                gp.parent = p;
              } else {
                /* zig-zag */
                if (r) {
                  gp.left = r;
                  r.parent = gp;
                } else gp.left = null;

                x.right   = gp;
                gp.parent = x;
              }
            }
            if (l) {
              p.right = l;
              l.parent = p;
            } else p.right = null;

            x.left   = p;
            p.parent = x;
          }
        }
      }


      replace(u, v) {
        if (!u.parent) this._root = v;
        else if (u === u.parent.left) u.parent.left = v;
        else u.parent.right = v;
        if (v) v.parent = u.parent;
      }


      minNode(u = this._root) {
        if (u) while (u.left) u = u.left;
        return u;
      }


      maxNode(u = this._root) {
        if (u) while (u.right) u = u.right;
        return u;
      }


      insert(key, data) {
        var z = this._root;
        var p = null;
        var comp = this._compare;
        var cmp;

        if (this._noDuplicates) {
          while (z) {
            p = z;
            cmp = comp(z.key, key);
            if (cmp === 0) return;
            else if (comp(z.key, key) < 0) z = z.right;
            else z = z.left;
          }
        } else {
          while (z) {
            p = z;
            if (comp(z.key, key) < 0) z = z.right;
            else z = z.left;
          }
        }

        z = { key, data, left: null, right: null, parent: p };

        if (!p)                          this._root = z;
        else if (comp(p.key, z.key) < 0) p.right = z;
        else                             p.left  = z;

        this.splay(z);
        this._size++;
        return z;
      }


      find (key) {
        var z    = this._root;
        var comp = this._compare;
        while (z) {
          var cmp = comp(z.key, key);
          if      (cmp < 0) z = z.right;
          else if (cmp > 0) z = z.left;
          else              return z;
        }
        return null;
      }

      /**
       * Whether the tree contains a node with the given key
       * @param  {Key} key
       * @return {boolean} true/false
       */
      contains (key) {
        var node       = this._root;
        var comparator = this._compare;
        while (node)  {
          var cmp = comparator(key, node.key);
          if      (cmp === 0) return true;
          else if (cmp < 0)   node = node.left;
          else                node = node.right;
        }

        return false;
      }


      remove (key) {
        var z = this.find(key);

        if (!z) return false;

        this.splay(z);

        if (!z.left) this.replace(z, z.right);
        else if (!z.right) this.replace(z, z.left);
        else {
          var y = this.minNode(z.right);
          if (y.parent !== z) {
            this.replace(y, y.right);
            y.right = z.right;
            y.right.parent = y;
          }
          this.replace(z, y);
          y.left = z.left;
          y.left.parent = y;
        }

        this._size--;
        return true;
      }


      removeNode(z) {
        if (!z) return false;

        this.splay(z);

        if (!z.left) this.replace(z, z.right);
        else if (!z.right) this.replace(z, z.left);
        else {
          var y = this.minNode(z.right);
          if (y.parent !== z) {
            this.replace(y, y.right);
            y.right = z.right;
            y.right.parent = y;
          }
          this.replace(z, y);
          y.left = z.left;
          y.left.parent = y;
        }

        this._size--;
        return true;
      }


      erase (key) {
        var z = this.find(key);
        if (!z) return;

        this.splay(z);

        var s = z.left;
        var t = z.right;

        var sMax = null;
        if (s) {
          s.parent = null;
          sMax = this.maxNode(s);
          this.splay(sMax);
          this._root = sMax;
        }
        if (t) {
          if (s) sMax.right = t;
          else   this._root = t;
          t.parent = sMax;
        }

        this._size--;
      }

      /**
       * Removes and returns the node with smallest key
       * @return {?Node}
       */
      pop () {
        var node = this._root, returnValue = null;
        if (node) {
          while (node.left) node = node.left;
          returnValue = { key: node.key, data: node.data };
          this.remove(node.key);
        }
        return returnValue;
      }


      /* eslint-disable class-methods-use-this */

      /**
       * Successor node
       * @param  {Node} node
       * @return {?Node}
       */
      next (node) {
        var successor = node;
        if (successor) {
          if (successor.right) {
            successor = successor.right;
            while (successor && successor.left) successor = successor.left;
          } else {
            successor = node.parent;
            while (successor && successor.right === node) {
              node = successor; successor = successor.parent;
            }
          }
        }
        return successor;
      }


      /**
       * Predecessor node
       * @param  {Node} node
       * @return {?Node}
       */
      prev (node) {
        var predecessor = node;
        if (predecessor) {
          if (predecessor.left) {
            predecessor = predecessor.left;
            while (predecessor && predecessor.right) predecessor = predecessor.right;
          } else {
            predecessor = node.parent;
            while (predecessor && predecessor.left === node) {
              node = predecessor;
              predecessor = predecessor.parent;
            }
          }
        }
        return predecessor;
      }
      /* eslint-enable class-methods-use-this */


      /**
       * @param  {forEachCallback} callback
       * @return {SplayTree}
       */
      forEach(callback) {
        var current = this._root;
        var s = [], done = false, i = 0;

        while (!done) {
          // Reach the left most Node of the current Node
          if (current) {
            // Place pointer to a tree node on the stack
            // before traversing the node's left subtree
            s.push(current);
            current = current.left;
          } else {
            // BackTrack from the empty subtree and visit the Node
            // at the top of the stack; however, if the stack is
            // empty you are done
            if (s.length > 0) {
              current = s.pop();
              callback(current, i++);

              // We have visited the node and its left
              // subtree. Now, it's right subtree's turn
              current = current.right;
            } else done = true;
          }
        }
        return this;
      }


      /**
       * Walk key range from `low` to `high`. Stops if `fn` returns a value.
       * @param  {Key}      low
       * @param  {Key}      high
       * @param  {Function} fn
       * @param  {*?}       ctx
       * @return {SplayTree}
       */
      range(low, high, fn, ctx) {
        const Q = [];
        const compare = this._compare;
        let node = this._root, cmp;

        while (Q.length !== 0 || node) {
          if (node) {
            Q.push(node);
            node = node.left;
          } else {
            node = Q.pop();
            cmp = compare(node.key, high);
            if (cmp > 0) {
              break;
            } else if (compare(node.key, low) >= 0) {
              if (fn.call(ctx, node)) return this; // stop if smth is returned
            }
            node = node.right;
          }
        }
        return this;
      }

      /**
       * Returns all keys in order
       * @return {Array<Key>}
       */
      keys () {
        var current = this._root;
        var s = [], r = [], done = false;

        while (!done) {
          if (current) {
            s.push(current);
            current = current.left;
          } else {
            if (s.length > 0) {
              current = s.pop();
              r.push(current.key);
              current = current.right;
            } else done = true;
          }
        }
        return r;
      }


      /**
       * Returns `data` fields of all nodes in order.
       * @return {Array<Value>}
       */
      values () {
        var current = this._root;
        var s = [], r = [], done = false;

        while (!done) {
          if (current) {
            s.push(current);
            current = current.left;
          } else {
            if (s.length > 0) {
              current = s.pop();
              r.push(current.data);
              current = current.right;
            } else done = true;
          }
        }
        return r;
      }


      /**
       * Returns node at given index
       * @param  {number} index
       * @return {?Node}
       */
      at (index) {
        // removed after a consideration, more misleading than useful
        // index = index % this.size;
        // if (index < 0) index = this.size - index;

        var current = this._root;
        var s = [], done = false, i = 0;

        while (!done) {
          if (current) {
            s.push(current);
            current = current.left;
          } else {
            if (s.length > 0) {
              current = s.pop();
              if (i === index) return current;
              i++;
              current = current.right;
            } else done = true;
          }
        }
        return null;
      }

      /**
       * Bulk-load items. Both array have to be same size
       * @param  {Array<Key>}    keys
       * @param  {Array<Value>}  [values]
       * @param  {Boolean}       [presort=false] Pre-sort keys and values, using
       *                                         tree's comparator. Sorting is done
       *                                         in-place
       * @return {AVLTree}
       */
      load(keys = [], values = [], presort = false) {
        if (this._size !== 0) throw new Error('bulk-load: tree is not empty');
        const size = keys.length;
        if (presort) sort(keys, values, 0, size - 1, this._compare);
        this._root = loadRecursive(null, keys, values, 0, size);
        this._size = size;
        return this;
      }


      min() {
        var node = this.minNode(this._root);
        if (node) return node.key;
        else      return null;
      }


      max() {
        var node = this.maxNode(this._root);
        if (node) return node.key;
        else      return null;
      }

      isEmpty() { return this._root === null; }
      get size() { return this._size; }


      /**
       * Create a tree and load it with items
       * @param  {Array<Key>}          keys
       * @param  {Array<Value>?}        [values]

       * @param  {Function?}            [comparator]
       * @param  {Boolean?}             [presort=false] Pre-sort keys and values, using
       *                                               tree's comparator. Sorting is done
       *                                               in-place
       * @param  {Boolean?}             [noDuplicates=false]   Allow duplicates
       * @return {SplayTree}
       */
      static createTree(keys, values, comparator, presort, noDuplicates) {
        return new SplayTree(comparator, noDuplicates).load(keys, values, presort);
      }
    }


    function loadRecursive (parent, keys, values, start, end) {
      const size = end - start;
      if (size > 0) {
        const middle = start + Math.floor(size / 2);
        const key    = keys[middle];
        const data   = values[middle];
        const node   = { key, data, parent };
        node.left    = loadRecursive(node, keys, values, start, middle);
        node.right   = loadRecursive(node, keys, values, middle + 1, end);
        return node;
      }
      return null;
    }


    function sort(keys, values, left, right, compare) {
      if (left >= right) return;

      const pivot = keys[(left + right) >> 1];
      let i = left - 1;
      let j = right + 1;

      while (true) {
        do i++; while (compare(keys[i], pivot) < 0);
        do j--; while (compare(keys[j], pivot) > 0);
        if (i >= j) break;

        let tmp = keys[i];
        keys[i] = keys[j];
        keys[j] = tmp;

        tmp = values[i];
        values[i] = values[j];
        values[j] = tmp;
      }

      sort(keys, values,  left,     j, compare);
      sort(keys, values, j + 1, right, compare);
    }

    const NORMAL               = 0;
    const NON_CONTRIBUTING     = 1;
    const SAME_TRANSITION      = 2;
    const DIFFERENT_TRANSITION = 3;

    const INTERSECTION = 0;
    const UNION        = 1;
    const DIFFERENCE   = 2;
    const XOR          = 3;

    /**
     * @param  {SweepEvent} event
     * @param  {SweepEvent} prev
     * @param  {Operation} operation
     */
    function computeFields (event, prev, operation) {
      // compute inOut and otherInOut fields
      if (prev === null) {
        event.inOut      = false;
        event.otherInOut = true;

      // previous line segment in sweepline belongs to the same polygon
      } else {
        if (event.isSubject === prev.isSubject) {
          event.inOut      = !prev.inOut;
          event.otherInOut = prev.otherInOut;

        // previous line segment in sweepline belongs to the clipping polygon
        } else {
          event.inOut      = !prev.otherInOut;
          event.otherInOut = prev.isVertical() ? !prev.inOut : prev.inOut;
        }

        // compute prevInResult field
        if (prev) {
          event.prevInResult = (!inResult(prev, operation) || prev.isVertical())
            ? prev.prevInResult : prev;
        }
      }

      // check if the line segment belongs to the Boolean operation
      let isInResult = inResult(event, operation);
      if (isInResult) {
        event.resultTransition = determineResultTransition(event, operation);
      } else {
        event.resultTransition = 0;
      }
    }


    /* eslint-disable indent */
    function inResult(event, operation) {
      switch (event.type) {
        case NORMAL:
          switch (operation) {
            case INTERSECTION:
              return !event.otherInOut;
            case UNION:
              return event.otherInOut;
            case DIFFERENCE:
              // return (event.isSubject && !event.otherInOut) ||
              //         (!event.isSubject && event.otherInOut);
              return (event.isSubject && event.otherInOut) ||
                      (!event.isSubject && !event.otherInOut);
            case XOR:
              return true;
          }
          break;
        case SAME_TRANSITION:
          return operation === INTERSECTION || operation === UNION;
        case DIFFERENT_TRANSITION:
          return operation === DIFFERENCE;
        case NON_CONTRIBUTING:
          return false;
      }
      return false;
    }
    /* eslint-enable indent */


    function determineResultTransition(event, operation) {
      let thisIn = !event.inOut;
      let thatIn = !event.otherInOut;

      let isIn;
      switch (operation) {
        case INTERSECTION:
          isIn = thisIn && thatIn; break;
        case UNION:
          isIn = thisIn || thatIn; break;
        case XOR:
          isIn = thisIn ^ thatIn; break;
        case DIFFERENCE:
          if (event.isSubject) {
            isIn = thisIn && !thatIn;
          } else {
            isIn = thatIn && !thisIn;
          }
          break;
      }
      return isIn ? +1 : -1;
    }

    class SweepEvent {


      /**
       * Sweepline event
       *
       * @class {SweepEvent}
       * @param {Array.<Number>}  point
       * @param {Boolean}         left
       * @param {SweepEvent=}     otherEvent
       * @param {Boolean}         isSubject
       * @param {Number}          edgeType
       */
      constructor (point, left, otherEvent, isSubject, edgeType) {

        /**
         * Is left endpoint?
         * @type {Boolean}
         */
        this.left = left;

        /**
         * @type {Array.<Number>}
         */
        this.point = point;

        /**
         * Other edge reference
         * @type {SweepEvent}
         */
        this.otherEvent = otherEvent;

        /**
         * Belongs to source or clipping polygon
         * @type {Boolean}
         */
        this.isSubject = isSubject;

        /**
         * Edge contribution type
         * @type {Number}
         */
        this.type = edgeType || NORMAL;


        /**
         * In-out transition for the sweepline crossing polygon
         * @type {Boolean}
         */
        this.inOut = false;


        /**
         * @type {Boolean}
         */
        this.otherInOut = false;

        /**
         * Previous event in result?
         * @type {SweepEvent}
         */
        this.prevInResult = null;

        /**
         * Type of result transition (0 = not in result, +1 = out-in, -1, in-out)
         * @type {Number}
         */
        this.resultTransition = 0;

        // connection step

        /**
         * @type {Number}
         */
        this.otherPos = -1;

        /**
         * @type {Number}
         */
        this.outputContourId = -1;

        this.isExteriorRing = true;   // TODO: Looks unused, remove?
      }


      /**
       * @param  {Array.<Number>}  p
       * @return {Boolean}
       */
      isBelow (p) {
        const p0 = this.point, p1 = this.otherEvent.point;
        return this.left
          ? (p0[0] - p[0]) * (p1[1] - p[1]) - (p1[0] - p[0]) * (p0[1] - p[1]) > 0
          // signedArea(this.point, this.otherEvent.point, p) > 0 :
          : (p1[0] - p[0]) * (p0[1] - p[1]) - (p0[0] - p[0]) * (p1[1] - p[1]) > 0;
          //signedArea(this.otherEvent.point, this.point, p) > 0;
      }


      /**
       * @param  {Array.<Number>}  p
       * @return {Boolean}
       */
      isAbove (p) {
        return !this.isBelow(p);
      }


      /**
       * @return {Boolean}
       */
      isVertical () {
        return this.point[0] === this.otherEvent.point[0];
      }


      /**
       * Does event belong to result?
       * @return {Boolean}
       */
      get inResult() {
        return this.resultTransition !== 0;
      }


      clone () {
        const copy = new SweepEvent(
          this.point, this.left, this.otherEvent, this.isSubject, this.type);

        copy.contourId        = this.contourId;
        copy.resultTransition = this.resultTransition;
        copy.prevInResult     = this.prevInResult;
        copy.isExteriorRing   = this.isExteriorRing;
        copy.inOut            = this.inOut;
        copy.otherInOut       = this.otherInOut;

        return copy;
      }
    }

    function equals(p1, p2) {
      if (p1[0] === p2[0]) {
        if (p1[1] === p2[1]) {
          return true;
        } else {
          return false;
        }
      }
      return false;
    }

    // const EPSILON = 1e-9;
    // const abs = Math.abs;
    // TODO https://github.com/w8r/martinez/issues/6#issuecomment-262847164
    // Precision problem.
    //
    // module.exports = function equals(p1, p2) {
    //   return abs(p1[0] - p2[0]) <= EPSILON && abs(p1[1] - p2[1]) <= EPSILON;
    // };

    const epsilon = 1.1102230246251565e-16;
    const splitter = 134217729;
    const resulterrbound = (3 + 8 * epsilon) * epsilon;

    // fast_expansion_sum_zeroelim routine from oritinal code
    function sum(elen, e, flen, f, h) {
        let Q, Qnew, hh, bvirt;
        let enow = e[0];
        let fnow = f[0];
        let eindex = 0;
        let findex = 0;
        if ((fnow > enow) === (fnow > -enow)) {
            Q = enow;
            enow = e[++eindex];
        } else {
            Q = fnow;
            fnow = f[++findex];
        }
        let hindex = 0;
        if (eindex < elen && findex < flen) {
            if ((fnow > enow) === (fnow > -enow)) {
                Qnew = enow + Q;
                hh = Q - (Qnew - enow);
                enow = e[++eindex];
            } else {
                Qnew = fnow + Q;
                hh = Q - (Qnew - fnow);
                fnow = f[++findex];
            }
            Q = Qnew;
            if (hh !== 0) {
                h[hindex++] = hh;
            }
            while (eindex < elen && findex < flen) {
                if ((fnow > enow) === (fnow > -enow)) {
                    Qnew = Q + enow;
                    bvirt = Qnew - Q;
                    hh = Q - (Qnew - bvirt) + (enow - bvirt);
                    enow = e[++eindex];
                } else {
                    Qnew = Q + fnow;
                    bvirt = Qnew - Q;
                    hh = Q - (Qnew - bvirt) + (fnow - bvirt);
                    fnow = f[++findex];
                }
                Q = Qnew;
                if (hh !== 0) {
                    h[hindex++] = hh;
                }
            }
        }
        while (eindex < elen) {
            Qnew = Q + enow;
            bvirt = Qnew - Q;
            hh = Q - (Qnew - bvirt) + (enow - bvirt);
            enow = e[++eindex];
            Q = Qnew;
            if (hh !== 0) {
                h[hindex++] = hh;
            }
        }
        while (findex < flen) {
            Qnew = Q + fnow;
            bvirt = Qnew - Q;
            hh = Q - (Qnew - bvirt) + (fnow - bvirt);
            fnow = f[++findex];
            Q = Qnew;
            if (hh !== 0) {
                h[hindex++] = hh;
            }
        }
        if (Q !== 0 || hindex === 0) {
            h[hindex++] = Q;
        }
        return hindex;
    }

    function estimate(elen, e) {
        let Q = e[0];
        for (let i = 1; i < elen; i++) Q += e[i];
        return Q;
    }

    function vec(n) {
        return new Float64Array(n);
    }

    const ccwerrboundA = (3 + 16 * epsilon) * epsilon;
    const ccwerrboundB = (2 + 12 * epsilon) * epsilon;
    const ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;

    const B = vec(4);
    const C1 = vec(8);
    const C2 = vec(12);
    const D = vec(16);
    const u = vec(4);

    function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
        let acxtail, acytail, bcxtail, bcytail;
        let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;

        const acx = ax - cx;
        const bcx = bx - cx;
        const acy = ay - cy;
        const bcy = by - cy;

        s1 = acx * bcy;
        c = splitter * acx;
        ahi = c - (c - acx);
        alo = acx - ahi;
        c = splitter * bcy;
        bhi = c - (c - bcy);
        blo = bcy - bhi;
        s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
        t1 = acy * bcx;
        c = splitter * acy;
        ahi = c - (c - acy);
        alo = acy - ahi;
        c = splitter * bcx;
        bhi = c - (c - bcx);
        blo = bcx - bhi;
        t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
        _i = s0 - t0;
        bvirt = s0 - _i;
        B[0] = s0 - (_i + bvirt) + (bvirt - t0);
        _j = s1 + _i;
        bvirt = _j - s1;
        _0 = s1 - (_j - bvirt) + (_i - bvirt);
        _i = _0 - t1;
        bvirt = _0 - _i;
        B[1] = _0 - (_i + bvirt) + (bvirt - t1);
        u3 = _j + _i;
        bvirt = u3 - _j;
        B[2] = _j - (u3 - bvirt) + (_i - bvirt);
        B[3] = u3;

        let det = estimate(4, B);
        let errbound = ccwerrboundB * detsum;
        if (det >= errbound || -det >= errbound) {
            return det;
        }

        bvirt = ax - acx;
        acxtail = ax - (acx + bvirt) + (bvirt - cx);
        bvirt = bx - bcx;
        bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
        bvirt = ay - acy;
        acytail = ay - (acy + bvirt) + (bvirt - cy);
        bvirt = by - bcy;
        bcytail = by - (bcy + bvirt) + (bvirt - cy);

        if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
            return det;
        }

        errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
        det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
        if (det >= errbound || -det >= errbound) return det;

        s1 = acxtail * bcy;
        c = splitter * acxtail;
        ahi = c - (c - acxtail);
        alo = acxtail - ahi;
        c = splitter * bcy;
        bhi = c - (c - bcy);
        blo = bcy - bhi;
        s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
        t1 = acytail * bcx;
        c = splitter * acytail;
        ahi = c - (c - acytail);
        alo = acytail - ahi;
        c = splitter * bcx;
        bhi = c - (c - bcx);
        blo = bcx - bhi;
        t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
        _i = s0 - t0;
        bvirt = s0 - _i;
        u[0] = s0 - (_i + bvirt) + (bvirt - t0);
        _j = s1 + _i;
        bvirt = _j - s1;
        _0 = s1 - (_j - bvirt) + (_i - bvirt);
        _i = _0 - t1;
        bvirt = _0 - _i;
        u[1] = _0 - (_i + bvirt) + (bvirt - t1);
        u3 = _j + _i;
        bvirt = u3 - _j;
        u[2] = _j - (u3 - bvirt) + (_i - bvirt);
        u[3] = u3;
        const C1len = sum(4, B, 4, u, C1);

        s1 = acx * bcytail;
        c = splitter * acx;
        ahi = c - (c - acx);
        alo = acx - ahi;
        c = splitter * bcytail;
        bhi = c - (c - bcytail);
        blo = bcytail - bhi;
        s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
        t1 = acy * bcxtail;
        c = splitter * acy;
        ahi = c - (c - acy);
        alo = acy - ahi;
        c = splitter * bcxtail;
        bhi = c - (c - bcxtail);
        blo = bcxtail - bhi;
        t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
        _i = s0 - t0;
        bvirt = s0 - _i;
        u[0] = s0 - (_i + bvirt) + (bvirt - t0);
        _j = s1 + _i;
        bvirt = _j - s1;
        _0 = s1 - (_j - bvirt) + (_i - bvirt);
        _i = _0 - t1;
        bvirt = _0 - _i;
        u[1] = _0 - (_i + bvirt) + (bvirt - t1);
        u3 = _j + _i;
        bvirt = u3 - _j;
        u[2] = _j - (u3 - bvirt) + (_i - bvirt);
        u[3] = u3;
        const C2len = sum(C1len, C1, 4, u, C2);

        s1 = acxtail * bcytail;
        c = splitter * acxtail;
        ahi = c - (c - acxtail);
        alo = acxtail - ahi;
        c = splitter * bcytail;
        bhi = c - (c - bcytail);
        blo = bcytail - bhi;
        s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
        t1 = acytail * bcxtail;
        c = splitter * acytail;
        ahi = c - (c - acytail);
        alo = acytail - ahi;
        c = splitter * bcxtail;
        bhi = c - (c - bcxtail);
        blo = bcxtail - bhi;
        t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
        _i = s0 - t0;
        bvirt = s0 - _i;
        u[0] = s0 - (_i + bvirt) + (bvirt - t0);
        _j = s1 + _i;
        bvirt = _j - s1;
        _0 = s1 - (_j - bvirt) + (_i - bvirt);
        _i = _0 - t1;
        bvirt = _0 - _i;
        u[1] = _0 - (_i + bvirt) + (bvirt - t1);
        u3 = _j + _i;
        bvirt = u3 - _j;
        u[2] = _j - (u3 - bvirt) + (_i - bvirt);
        u[3] = u3;
        const Dlen = sum(C2len, C2, 4, u, D);

        return D[Dlen - 1];
    }

    function orient2d(ax, ay, bx, by, cx, cy) {
        const detleft = (ay - cy) * (bx - cx);
        const detright = (ax - cx) * (by - cy);
        const det = detleft - detright;

        if (detleft === 0 || detright === 0 || (detleft > 0) !== (detright > 0)) return det;

        const detsum = Math.abs(detleft + detright);
        if (Math.abs(det) >= ccwerrboundA * detsum) return det;

        return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
    }

    /**
     * Signed area of the triangle (p0, p1, p2)
     * @param  {Array.<Number>} p0
     * @param  {Array.<Number>} p1
     * @param  {Array.<Number>} p2
     * @return {Number}
     */
    function signedArea(p0, p1, p2) {
      const res = orient2d(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1]);
      if (res > 0) return -1;
      if (res < 0) return 1;
      return 0;
    }

    /**
     * @param  {SweepEvent} e1
     * @param  {SweepEvent} e2
     * @return {Number}
     */
    function compareEvents(e1, e2) {
      const p1 = e1.point;
      const p2 = e2.point;

      // Different x-coordinate
      if (p1[0] > p2[0]) return 1;
      if (p1[0] < p2[0]) return -1;

      // Different points, but same x-coordinate
      // Event with lower y-coordinate is processed first
      if (p1[1] !== p2[1]) return p1[1] > p2[1] ? 1 : -1;

      return specialCases(e1, e2, p1);
    }


    /* eslint-disable no-unused-vars */
    function specialCases(e1, e2, p1, p2) {
      // Same coordinates, but one is a left endpoint and the other is
      // a right endpoint. The right endpoint is processed first
      if (e1.left !== e2.left)
        return e1.left ? 1 : -1;

      // const p2 = e1.otherEvent.point, p3 = e2.otherEvent.point;
      // const sa = (p1[0] - p3[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[1] - p3[1])
      // Same coordinates, both events
      // are left endpoints or right endpoints.
      // not collinear
      if (signedArea(p1, e1.otherEvent.point, e2.otherEvent.point) !== 0) {
        // the event associate to the bottom segment is processed first
        return (!e1.isBelow(e2.otherEvent.point)) ? 1 : -1;
      }

      return (!e1.isSubject && e2.isSubject) ? 1 : -1;
    }
    /* eslint-enable no-unused-vars */

    /**
     * @param  {SweepEvent} se
     * @param  {Array.<Number>} p
     * @param  {Queue} queue
     * @return {Queue}
     */
    function divideSegment(se, p, queue)  {
      const r = new SweepEvent(p, false, se,            se.isSubject);
      const l = new SweepEvent(p, true,  se.otherEvent, se.isSubject);

      /* eslint-disable no-console */
      if (equals(se.point, se.otherEvent.point)) {
        console.warn('what is that, a collapsed segment?', se);
      }
      /* eslint-enable no-console */

      r.contourId = l.contourId = se.contourId;

      // avoid a rounding error. The left event would be processed after the right event
      if (compareEvents(l, se.otherEvent) > 0) {
        se.otherEvent.left = true;
        l.left = false;
      }

      // avoid a rounding error. The left event would be processed after the right event
      // if (compareEvents(se, r) > 0) {}

      se.otherEvent.otherEvent = l;
      se.otherEvent = r;

      queue.push(l);
      queue.push(r);

      return queue;
    }

    //const EPS = 1e-9;

    /**
     * Finds the magnitude of the cross product of two vectors (if we pretend
     * they're in three dimensions)
     *
     * @param {Object} a First vector
     * @param {Object} b Second vector
     * @private
     * @returns {Number} The magnitude of the cross product
     */
    function crossProduct(a, b) {
      return (a[0] * b[1]) - (a[1] * b[0]);
    }

    /**
     * Finds the dot product of two vectors.
     *
     * @param {Object} a First vector
     * @param {Object} b Second vector
     * @private
     * @returns {Number} The dot product
     */
    function dotProduct(a, b) {
      return (a[0] * b[0]) + (a[1] * b[1]);
    }

    /**
     * Finds the intersection (if any) between two line segments a and b, given the
     * line segments' end points a1, a2 and b1, b2.
     *
     * This algorithm is based on Schneider and Eberly.
     * http://www.cimec.org.ar/~ncalvo/Schneider_Eberly.pdf
     * Page 244.
     *
     * @param {Array.<Number>} a1 point of first line
     * @param {Array.<Number>} a2 point of first line
     * @param {Array.<Number>} b1 point of second line
     * @param {Array.<Number>} b2 point of second line
     * @param {Boolean=}       noEndpointTouch whether to skip single touchpoints
     *                                         (meaning connected segments) as
     *                                         intersections
     * @returns {Array.<Array.<Number>>|Null} If the lines intersect, the point of
     * intersection. If they overlap, the two end points of the overlapping segment.
     * Otherwise, null.
     */
    function intersection$1 (a1, a2, b1, b2, noEndpointTouch) {
      // The algorithm expects our lines in the form P + sd, where P is a point,
      // s is on the interval [0, 1], and d is a vector.
      // We are passed two points. P can be the first point of each pair. The
      // vector, then, could be thought of as the distance (in x and y components)
      // from the first point to the second point.
      // So first, let's make our vectors:
      const va = [a2[0] - a1[0], a2[1] - a1[1]];
      const vb = [b2[0] - b1[0], b2[1] - b1[1]];
      // We also define a function to convert back to regular point form:

      /* eslint-disable arrow-body-style */

      function toPoint(p, s, d) {
        return [
          p[0] + s * d[0],
          p[1] + s * d[1]
        ];
      }

      /* eslint-enable arrow-body-style */

      // The rest is pretty much a straight port of the algorithm.
      const e = [b1[0] - a1[0], b1[1] - a1[1]];
      let kross    = crossProduct(va, vb);
      let sqrKross = kross * kross;
      const sqrLenA  = dotProduct(va, va);
      //const sqrLenB  = dotProduct(vb, vb);

      // Check for line intersection. This works because of the properties of the
      // cross product -- specifically, two vectors are parallel if and only if the
      // cross product is the 0 vector. The full calculation involves relative error
      // to account for possible very small line segments. See Schneider & Eberly
      // for details.
      if (sqrKross > 0/* EPS * sqrLenB * sqLenA */) {
        // If they're not parallel, then (because these are line segments) they
        // still might not actually intersect. This code checks that the
        // intersection point of the lines is actually on both line segments.
        const s = crossProduct(e, vb) / kross;
        if (s < 0 || s > 1) {
          // not on line segment a
          return null;
        }
        const t = crossProduct(e, va) / kross;
        if (t < 0 || t > 1) {
          // not on line segment b
          return null;
        }
        if (s === 0 || s === 1) {
          // on an endpoint of line segment a
          return noEndpointTouch ? null : [toPoint(a1, s, va)];
        }
        if (t === 0 || t === 1) {
          // on an endpoint of line segment b
          return noEndpointTouch ? null : [toPoint(b1, t, vb)];
        }
        return [toPoint(a1, s, va)];
      }

      // If we've reached this point, then the lines are either parallel or the
      // same, but the segments could overlap partially or fully, or not at all.
      // So we need to find the overlap, if any. To do that, we can use e, which is
      // the (vector) difference between the two initial points. If this is parallel
      // with the line itself, then the two lines are the same line, and there will
      // be overlap.
      //const sqrLenE = dotProduct(e, e);
      kross = crossProduct(e, va);
      sqrKross = kross * kross;

      if (sqrKross > 0 /* EPS * sqLenB * sqLenE */) {
      // Lines are just parallel, not the same. No overlap.
        return null;
      }

      const sa = dotProduct(va, e) / sqrLenA;
      const sb = sa + dotProduct(va, vb) / sqrLenA;
      const smin = Math.min(sa, sb);
      const smax = Math.max(sa, sb);

      // this is, essentially, the FindIntersection acting on floats from
      // Schneider & Eberly, just inlined into this function.
      if (smin <= 1 && smax >= 0) {

        // overlap on an end point
        if (smin === 1) {
          return noEndpointTouch ? null : [toPoint(a1, smin > 0 ? smin : 0, va)];
        }

        if (smax === 0) {
          return noEndpointTouch ? null : [toPoint(a1, smax < 1 ? smax : 1, va)];
        }

        if (noEndpointTouch && smin === 0 && smax === 1) return null;

        // There's overlap on a segment -- two points of intersection. Return both.
        return [
          toPoint(a1, smin > 0 ? smin : 0, va),
          toPoint(a1, smax < 1 ? smax : 1, va)
        ];
      }

      return null;
    }

    /**
     * @param  {SweepEvent} se1
     * @param  {SweepEvent} se2
     * @param  {Queue}      queue
     * @return {Number}
     */
    function possibleIntersection (se1, se2, queue) {
      // that disallows self-intersecting polygons,
      // did cost us half a day, so I'll leave it
      // out of respect
      // if (se1.isSubject === se2.isSubject) return;
      const inter = intersection$1(
        se1.point, se1.otherEvent.point,
        se2.point, se2.otherEvent.point
      );

      const nintersections = inter ? inter.length : 0;
      if (nintersections === 0) return 0; // no intersection

      // the line segments intersect at an endpoint of both line segments
      if ((nintersections === 1) &&
          (equals(se1.point, se2.point) ||
           equals(se1.otherEvent.point, se2.otherEvent.point))) {
        return 0;
      }

      if (nintersections === 2 && se1.isSubject === se2.isSubject) {
        // if(se1.contourId === se2.contourId){
        // console.warn('Edges of the same polygon overlap',
        //   se1.point, se1.otherEvent.point, se2.point, se2.otherEvent.point);
        // }
        //throw new Error('Edges of the same polygon overlap');
        return 0;
      }

      // The line segments associated to se1 and se2 intersect
      if (nintersections === 1) {

        // if the intersection point is not an endpoint of se1
        if (!equals(se1.point, inter[0]) && !equals(se1.otherEvent.point, inter[0])) {
          divideSegment(se1, inter[0], queue);
        }

        // if the intersection point is not an endpoint of se2
        if (!equals(se2.point, inter[0]) && !equals(se2.otherEvent.point, inter[0])) {
          divideSegment(se2, inter[0], queue);
        }
        return 1;
      }

      // The line segments associated to se1 and se2 overlap
      const events        = [];
      let leftCoincide  = false;
      let rightCoincide = false;

      if (equals(se1.point, se2.point)) {
        leftCoincide = true; // linked
      } else if (compareEvents(se1, se2) === 1) {
        events.push(se2, se1);
      } else {
        events.push(se1, se2);
      }

      if (equals(se1.otherEvent.point, se2.otherEvent.point)) {
        rightCoincide = true;
      } else if (compareEvents(se1.otherEvent, se2.otherEvent) === 1) {
        events.push(se2.otherEvent, se1.otherEvent);
      } else {
        events.push(se1.otherEvent, se2.otherEvent);
      }

      if ((leftCoincide && rightCoincide) || leftCoincide) {
        // both line segments are equal or share the left endpoint
        se2.type = NON_CONTRIBUTING;
        se1.type = (se2.inOut === se1.inOut)
          ? SAME_TRANSITION : DIFFERENT_TRANSITION;

        if (leftCoincide && !rightCoincide) {
          // honestly no idea, but changing events selection from [2, 1]
          // to [0, 1] fixes the overlapping self-intersecting polygons issue
          divideSegment(events[1].otherEvent, events[0].point, queue);
        }
        return 2;
      }

      // the line segments share the right endpoint
      if (rightCoincide) {
        divideSegment(events[0], events[1].point, queue);
        return 3;
      }

      // no line segment includes totally the other one
      if (events[0] !== events[3].otherEvent) {
        divideSegment(events[0], events[1].point, queue);
        divideSegment(events[1], events[2].point, queue);
        return 3;
      }

      // one line segment includes the other one
      divideSegment(events[0], events[1].point, queue);
      divideSegment(events[3].otherEvent, events[2].point, queue);

      return 3;
    }

    /**
     * @param  {SweepEvent} le1
     * @param  {SweepEvent} le2
     * @return {Number}
     */
    function compareSegments(le1, le2) {
      if (le1 === le2) return 0;

      // Segments are not collinear
      if (signedArea(le1.point, le1.otherEvent.point, le2.point) !== 0 ||
        signedArea(le1.point, le1.otherEvent.point, le2.otherEvent.point) !== 0) {

        // If they share their left endpoint use the right endpoint to sort
        if (equals(le1.point, le2.point)) return le1.isBelow(le2.otherEvent.point) ? -1 : 1;

        // Different left endpoint: use the left endpoint to sort
        if (le1.point[0] === le2.point[0]) return le1.point[1] < le2.point[1] ? -1 : 1;

        // has the line segment associated to e1 been inserted
        // into S after the line segment associated to e2 ?
        if (compareEvents(le1, le2) === 1) return le2.isAbove(le1.point) ? -1 : 1;

        // The line segment associated to e2 has been inserted
        // into S after the line segment associated to e1
        return le1.isBelow(le2.point) ? -1 : 1;
      }

      if (le1.isSubject === le2.isSubject) { // same polygon
        let p1 = le1.point, p2 = le2.point;
        if (p1[0] === p2[0] && p1[1] === p2[1]/*equals(le1.point, le2.point)*/) {
          p1 = le1.otherEvent.point; p2 = le2.otherEvent.point;
          if (p1[0] === p2[0] && p1[1] === p2[1]) return 0;
          else return le1.contourId > le2.contourId ? 1 : -1;
        }
      } else { // Segments are collinear, but belong to separate polygons
        return le1.isSubject ? -1 : 1;
      }

      return compareEvents(le1, le2) === 1 ? 1 : -1;
    }

    function subdivide(eventQueue, subject, clipping, sbbox, cbbox, operation) {
      const sweepLine = new SplayTree(compareSegments);
      const sortedEvents = [];

      const rightbound = Math.min(sbbox[2], cbbox[2]);

      let prev, next, begin;

      while (eventQueue.length !== 0) {
        let event = eventQueue.pop();
        sortedEvents.push(event);

        // optimization by bboxes for intersection and difference goes here
        if ((operation === INTERSECTION && event.point[0] > rightbound) ||
            (operation === DIFFERENCE   && event.point[0] > sbbox[2])) {
          break;
        }

        if (event.left) {
          next  = prev = sweepLine.insert(event);
          begin = sweepLine.minNode();

          if (prev !== begin) prev = sweepLine.prev(prev);
          else                prev = null;

          next = sweepLine.next(next);

          const prevEvent = prev ? prev.key : null;
          let prevprevEvent;
          computeFields(event, prevEvent, operation);
          if (next) {
            if (possibleIntersection(event, next.key, eventQueue) === 2) {
              computeFields(event, prevEvent, operation);
              computeFields(event, next.key, operation);
            }
          }

          if (prev) {
            if (possibleIntersection(prev.key, event, eventQueue) === 2) {
              let prevprev = prev;
              if (prevprev !== begin) prevprev = sweepLine.prev(prevprev);
              else                    prevprev = null;

              prevprevEvent = prevprev ? prevprev.key : null;
              computeFields(prevEvent, prevprevEvent, operation);
              computeFields(event,     prevEvent,     operation);
            }
          }
        } else {
          event = event.otherEvent;
          next = prev = sweepLine.find(event);

          if (prev && next) {

            if (prev !== begin) prev = sweepLine.prev(prev);
            else                prev = null;

            next = sweepLine.next(next);
            sweepLine.remove(event);

            if (next && prev) {
              possibleIntersection(prev.key, next.key, eventQueue);
            }
          }
        }
      }
      return sortedEvents;
    }

    class Contour {

      /**
       * Contour
       *
       * @class {Contour}
       */
      constructor() {
        this.points = [];
        this.holeIds = [];
        this.holeOf = null;
        this.depth = null;
      }

      isExterior() {
        return this.holeOf == null;
      }

    }

    /**
     * @param  {Array.<SweepEvent>} sortedEvents
     * @return {Array.<SweepEvent>}
     */
    function orderEvents(sortedEvents) {
      let event, i, len, tmp;
      const resultEvents = [];
      for (i = 0, len = sortedEvents.length; i < len; i++) {
        event = sortedEvents[i];
        if ((event.left && event.inResult) ||
          (!event.left && event.otherEvent.inResult)) {
          resultEvents.push(event);
        }
      }
      // Due to overlapping edges the resultEvents array can be not wholly sorted
      let sorted = false;
      while (!sorted) {
        sorted = true;
        for (i = 0, len = resultEvents.length; i < len; i++) {
          if ((i + 1) < len &&
            compareEvents(resultEvents[i], resultEvents[i + 1]) === 1) {
            tmp = resultEvents[i];
            resultEvents[i] = resultEvents[i + 1];
            resultEvents[i + 1] = tmp;
            sorted = false;
          }
        }
      }


      for (i = 0, len = resultEvents.length; i < len; i++) {
        event = resultEvents[i];
        event.otherPos = i;
      }

      // imagine, the right event is found in the beginning of the queue,
      // when his left counterpart is not marked yet
      for (i = 0, len = resultEvents.length; i < len; i++) {
        event = resultEvents[i];
        if (!event.left) {
          tmp = event.otherPos;
          event.otherPos = event.otherEvent.otherPos;
          event.otherEvent.otherPos = tmp;
        }
      }

      return resultEvents;
    }


    /**
     * @param  {Number} pos
     * @param  {Array.<SweepEvent>} resultEvents
     * @param  {Object>}    processed
     * @return {Number}
     */
    function nextPos(pos, resultEvents, processed, origPos) {
      let newPos = pos + 1,
          p = resultEvents[pos].point,
          p1;
      const length = resultEvents.length;

      if (newPos < length)
        p1 = resultEvents[newPos].point;

      while (newPos < length && p1[0] === p[0] && p1[1] === p[1]) {
        if (!processed[newPos]) {
          return newPos;
        } else   {
          newPos++;
        }
        p1 = resultEvents[newPos].point;
      }

      newPos = pos - 1;

      while (processed[newPos] && newPos > origPos) {
        newPos--;
      }

      return newPos;
    }


    function initializeContourFromContext(event, contours, contourId) {
      const contour = new Contour();
      if (event.prevInResult != null) {
        const prevInResult = event.prevInResult;
        // Note that it is valid to query the "previous in result" for its output contour id,
        // because we must have already processed it (i.e., assigned an output contour id)
        // in an earlier iteration, otherwise it wouldn't be possible that it is "previous in
        // result".
        const lowerContourId = prevInResult.outputContourId;
        const lowerResultTransition = prevInResult.resultTransition;
        if (lowerResultTransition > 0) {
          // We are inside. Now we have to check if the thing below us is another hole or
          // an exterior contour.
          const lowerContour = contours[lowerContourId];
          if (lowerContour.holeOf != null) {
            // The lower contour is a hole => Connect the new contour as a hole to its parent,
            // and use same depth.
            const parentContourId = lowerContour.holeOf;
            contours[parentContourId].holeIds.push(contourId);
            contour.holeOf = parentContourId;
            contour.depth = contours[lowerContourId].depth;
          } else {
            // The lower contour is an exterior contour => Connect the new contour as a hole,
            // and increment depth.
            contours[lowerContourId].holeIds.push(contourId);
            contour.holeOf = lowerContourId;
            contour.depth = contours[lowerContourId].depth + 1;
          }
        } else {
          // We are outside => this contour is an exterior contour of same depth.
          contour.holeOf = null;
          contour.depth = contours[lowerContourId].depth;
        }
      } else {
        // There is no lower/previous contour => this contour is an exterior contour of depth 0.
        contour.holeOf = null;
        contour.depth = 0;
      }
      return contour;
    }

    /**
     * @param  {Array.<SweepEvent>} sortedEvents
     * @return {Array.<*>} polygons
     */
    function connectEdges(sortedEvents) {
      let i, len;
      const resultEvents = orderEvents(sortedEvents);

      // "false"-filled array
      const processed = {};
      const contours = [];

      for (i = 0, len = resultEvents.length; i < len; i++) {

        if (processed[i]) {
          continue;
        }

        const contourId = contours.length;
        const contour = initializeContourFromContext(resultEvents[i], contours, contourId);

        // Helper function that combines marking an event as processed with assigning its output contour ID
        const markAsProcessed = (pos) => {
          processed[pos] = true;
          resultEvents[pos].outputContourId = contourId;
        };

        let pos = i;
        let origPos = i;

        const initial = resultEvents[i].point;
        contour.points.push(initial);

        /* eslint no-constant-condition: "off" */
        while (true) {
          markAsProcessed(pos);

          pos = resultEvents[pos].otherPos;

          markAsProcessed(pos);
          contour.points.push(resultEvents[pos].point);

          pos = nextPos(pos, resultEvents, processed, origPos);

          if (pos == origPos) {
            break;
          }
        }

        contours.push(contour);
      }

      return contours;
    }

    var tinyqueue = TinyQueue;
    var _default = TinyQueue;

    function TinyQueue(data, compare) {
        if (!(this instanceof TinyQueue)) return new TinyQueue(data, compare);

        this.data = data || [];
        this.length = this.data.length;
        this.compare = compare || defaultCompare;

        if (this.length > 0) {
            for (var i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
        }
    }

    function defaultCompare(a, b) {
        return a < b ? -1 : a > b ? 1 : 0;
    }

    TinyQueue.prototype = {

        push: function (item) {
            this.data.push(item);
            this.length++;
            this._up(this.length - 1);
        },

        pop: function () {
            if (this.length === 0) return undefined;

            var top = this.data[0];
            this.length--;

            if (this.length > 0) {
                this.data[0] = this.data[this.length];
                this._down(0);
            }
            this.data.pop();

            return top;
        },

        peek: function () {
            return this.data[0];
        },

        _up: function (pos) {
            var data = this.data;
            var compare = this.compare;
            var item = data[pos];

            while (pos > 0) {
                var parent = (pos - 1) >> 1;
                var current = data[parent];
                if (compare(item, current) >= 0) break;
                data[pos] = current;
                pos = parent;
            }

            data[pos] = item;
        },

        _down: function (pos) {
            var data = this.data;
            var compare = this.compare;
            var halfLength = this.length >> 1;
            var item = data[pos];

            while (pos < halfLength) {
                var left = (pos << 1) + 1;
                var right = left + 1;
                var best = data[left];

                if (right < this.length && compare(data[right], best) < 0) {
                    left = right;
                    best = data[right];
                }
                if (compare(best, item) >= 0) break;

                data[pos] = best;
                pos = left;
            }

            data[pos] = item;
        }
    };
    tinyqueue.default = _default;

    const max = Math.max;
    const min = Math.min;

    let contourId = 0;


    function processPolygon(contourOrHole, isSubject, depth, Q, bbox, isExteriorRing) {
      let i, len, s1, s2, e1, e2;
      for (i = 0, len = contourOrHole.length - 1; i < len; i++) {
        s1 = contourOrHole[i];
        s2 = contourOrHole[i + 1];
        e1 = new SweepEvent(s1, false, undefined, isSubject);
        e2 = new SweepEvent(s2, false, e1,        isSubject);
        e1.otherEvent = e2;

        if (s1[0] === s2[0] && s1[1] === s2[1]) {
          continue; // skip collapsed edges, or it breaks
        }

        e1.contourId = e2.contourId = depth;
        if (!isExteriorRing) {
          e1.isExteriorRing = false;
          e2.isExteriorRing = false;
        }
        if (compareEvents(e1, e2) > 0) {
          e2.left = true;
        } else {
          e1.left = true;
        }

        const x = s1[0], y = s1[1];
        bbox[0] = min(bbox[0], x);
        bbox[1] = min(bbox[1], y);
        bbox[2] = max(bbox[2], x);
        bbox[3] = max(bbox[3], y);

        // Pushing it so the queue is sorted from left to right,
        // with object on the left having the highest priority.
        Q.push(e1);
        Q.push(e2);
      }
    }


    function fillQueue(subject, clipping, sbbox, cbbox, operation) {
      const eventQueue = new tinyqueue(null, compareEvents);
      let polygonSet, isExteriorRing, i, ii, j, jj; //, k, kk;

      for (i = 0, ii = subject.length; i < ii; i++) {
        polygonSet = subject[i];
        for (j = 0, jj = polygonSet.length; j < jj; j++) {
          isExteriorRing = j === 0;
          if (isExteriorRing) contourId++;
          processPolygon(polygonSet[j], true, contourId, eventQueue, sbbox, isExteriorRing);
        }
      }

      for (i = 0, ii = clipping.length; i < ii; i++) {
        polygonSet = clipping[i];
        for (j = 0, jj = polygonSet.length; j < jj; j++) {
          isExteriorRing = j === 0;
          if (operation === DIFFERENCE) isExteriorRing = false;
          if (isExteriorRing) contourId++;
          processPolygon(polygonSet[j], false, contourId, eventQueue, cbbox, isExteriorRing);
        }
      }

      return eventQueue;
    }

    const EMPTY = [];


    function trivialOperation(subject, clipping, operation) {
      let result = null;
      if (subject.length * clipping.length === 0) {
        if        (operation === INTERSECTION) {
          result = EMPTY;
        } else if (operation === DIFFERENCE) {
          result = subject;
        } else if (operation === UNION ||
                   operation === XOR) {
          result = (subject.length === 0) ? clipping : subject;
        }
      }
      return result;
    }


    function compareBBoxes(subject, clipping, sbbox, cbbox, operation) {
      let result = null;
      if (sbbox[0] > cbbox[2] ||
          cbbox[0] > sbbox[2] ||
          sbbox[1] > cbbox[3] ||
          cbbox[1] > sbbox[3]) {
        if        (operation === INTERSECTION) {
          result = EMPTY;
        } else if (operation === DIFFERENCE) {
          result = subject;
        } else if (operation === UNION ||
                   operation === XOR) {
          result = subject.concat(clipping);
        }
      }
      return result;
    }


    function boolean(subject, clipping, operation) {
      if (typeof subject[0][0][0] === 'number') {
        subject = [subject];
      }
      if (typeof clipping[0][0][0] === 'number') {
        clipping = [clipping];
      }
      let trivial = trivialOperation(subject, clipping, operation);
      if (trivial) {
        return trivial === EMPTY ? null : trivial;
      }
      const sbbox = [Infinity, Infinity, -Infinity, -Infinity];
      const cbbox = [Infinity, Infinity, -Infinity, -Infinity];

      // console.time('fill queue');
      const eventQueue = fillQueue(subject, clipping, sbbox, cbbox, operation);
      //console.timeEnd('fill queue');

      trivial = compareBBoxes(subject, clipping, sbbox, cbbox, operation);
      if (trivial) {
        return trivial === EMPTY ? null : trivial;
      }
      // console.time('subdivide edges');
      const sortedEvents = subdivide(eventQueue, subject, clipping, sbbox, cbbox, operation);
      //console.timeEnd('subdivide edges');

      // console.time('connect vertices');
      const contours = connectEdges(sortedEvents);
      //console.timeEnd('connect vertices');

      // Convert contours to polygons
      const polygons = [];
      for (let i = 0; i < contours.length; i++) {
        let contour = contours[i];
        if (contour.isExterior()) {
          // The exterior ring goes first
          let rings = [contour.points];
          // Followed by holes if any
          for (let j = 0; j < contour.holeIds.length; j++) {
            let holeId = contour.holeIds[j];
            rings.push(contours[holeId].points);
          }
          polygons.push(rings);
        }
      }

      return polygons;
    }

    function intersection (subject, clipping) {
      return boolean(subject, clipping, INTERSECTION);
    }

    /**
     * @class VertexGeometry
     * @abstract
     * @classdesc Represents a vertex geometry.
     */
    class VertexGeometry extends Geometry {
        /**
         * Create a vertex geometry.
         *
         * @constructor
         * @ignore
         */
        constructor() {
            super();
            this._subsampleThreshold = 0.005;
        }
        /**
         * Finds the polygon pole of inaccessibility, the most distant internal
         * point from the polygon outline.
         *
         * @param {Array<Array<number>>} points2d - 2d points of outline to triangulate.
         * @returns {Array<number>} Point of inaccessibility.
         * @ignore
         */
        _getPoleOfInaccessibility2d(points2d) {
            let pole2d = polylabel_1([points2d], 3e-2);
            return pole2d;
        }
        _project(points2d, transform) {
            const camera = this._createCamera(transform.upVector().toArray(), transform.unprojectSfM([0, 0], 0), transform.unprojectSfM([0, 0], 10));
            return this._deunproject(points2d, transform, camera);
        }
        _subsample(points2d, threshold = this._subsampleThreshold) {
            const subsampled = [];
            const length = points2d.length;
            for (let index = 0; index < length; index++) {
                const p1 = points2d[index];
                const p2 = points2d[(index + 1) % length];
                subsampled.push(p1);
                const dist = Math.sqrt(Math.pow((p2[0] - p1[0]), 2) + Math.pow((p2[1] - p1[1]), 2));
                const subsamples = Math.floor(dist / threshold);
                const coeff = 1 / (subsamples + 1);
                for (let i = 1; i <= subsamples; i++) {
                    const alpha = i * coeff;
                    const subsample = [
                        (1 - alpha) * p1[0] + alpha * p2[0],
                        (1 - alpha) * p1[1] + alpha * p2[1],
                    ];
                    subsampled.push(subsample);
                }
            }
            return subsampled;
        }
        /**
         * Triangulates a 2d polygon and returns the triangle
         * representation as a flattened array of 3d points.
         *
         * @param {Array<Array<number>>} points2d - 2d points of outline to triangulate.
         * @param {Array<Array<number>>} points3d - 3d points of outline corresponding to the 2d points.
         * @param {Array<Array<Array<number>>>} [holes2d] - 2d points of holes to triangulate.
         * @param {Array<Array<Array<number>>>} [holes3d] - 3d points of holes corresponding to the 2d points.
         * @returns {Array<number>} Flattened array of 3d points ordered based on the triangles.
         * @ignore
         */
        _triangulate(points2d, points3d, holes2d, holes3d) {
            let data = [points2d.slice(0, -1)];
            for (let hole2d of holes2d != null ? holes2d : []) {
                data.push(hole2d.slice(0, -1));
            }
            let points = points3d.slice(0, -1);
            for (let hole3d of holes3d != null ? holes3d : []) {
                points = points.concat(hole3d.slice(0, -1));
            }
            let flattened = earcut_1.flatten(data);
            let indices = earcut_1(flattened.vertices, flattened.holes, flattened.dimensions);
            let triangles = [];
            for (let i = 0; i < indices.length; ++i) {
                let point = points[indices[i]];
                triangles.push(point[0]);
                triangles.push(point[1]);
                triangles.push(point[2]);
            }
            return triangles;
        }
        _triangulateSpherical(points2d, holes2d, transform) {
            const triangles = [];
            const epsilon = 1e-9;
            const subareasX = 3;
            const subareasY = 3;
            for (let x = 0; x < subareasX; x++) {
                for (let y = 0; y < subareasY; y++) {
                    const epsilonX0 = x === 0 ? -epsilon : epsilon;
                    const epsilonY0 = y === 0 ? -epsilon : epsilon;
                    const x0 = x / subareasX + epsilonX0;
                    const y0 = y / subareasY + epsilonY0;
                    const x1 = (x + 1) / subareasX + epsilon;
                    const y1 = (y + 1) / subareasY + epsilon;
                    const bbox2d = [
                        [x0, y0],
                        [x0, y1],
                        [x1, y1],
                        [x1, y0],
                        [x0, y0],
                    ];
                    const lookat2d = [
                        (2 * x + 1) / (2 * subareasX),
                        (2 * y + 1) / (2 * subareasY),
                    ];
                    triangles.push(...this._triangulateSubarea(points2d, holes2d, bbox2d, lookat2d, transform));
                }
            }
            return triangles;
        }
        _unproject(points2d, transform, distance = 200) {
            return points2d
                .map((point) => {
                return transform.unprojectBasic(point, distance);
            });
        }
        _createCamera(upVector, position, lookAt) {
            const camera = new Camera$1();
            camera.up.copy(new Vector3().fromArray(upVector));
            camera.position.copy(new Vector3().fromArray(position));
            camera.lookAt(new Vector3().fromArray(lookAt));
            camera.updateMatrix();
            camera.updateMatrixWorld(true);
            return camera;
        }
        _deunproject(points2d, transform, camera) {
            return points2d
                .map((point2d) => {
                const pointWorld = transform.unprojectBasic(point2d, 10000);
                const pointCamera = new Vector3(pointWorld[0], pointWorld[1], pointWorld[2])
                    .applyMatrix4(camera.matrixWorldInverse);
                return [pointCamera.x / pointCamera.z, pointCamera.y / pointCamera.z];
            });
        }
        _triangulateSubarea(points2d, holes2d, bbox2d, lookat2d, transform) {
            const intersections = intersection([points2d, ...holes2d], [bbox2d]);
            if (!intersections) {
                return [];
            }
            const triangles = [];
            const threshold = this._subsampleThreshold;
            const camera = this._createCamera(transform.upVector().toArray(), transform.unprojectSfM([0, 0], 0), transform.unprojectBasic(lookat2d, 10));
            for (const intersection of intersections) {
                const subsampledPolygon2d = this._subsample(intersection[0], threshold);
                const polygon2d = this._deunproject(subsampledPolygon2d, transform, camera);
                const polygon3d = this._unproject(subsampledPolygon2d, transform);
                const polygonHoles2d = [];
                const polygonHoles3d = [];
                for (let i = 1; i < intersection.length; i++) {
                    let subsampledHole2d = this._subsample(intersection[i], threshold);
                    const hole2d = this._deunproject(subsampledHole2d, transform, camera);
                    const hole3d = this._unproject(subsampledHole2d, transform);
                    polygonHoles2d.push(hole2d);
                    polygonHoles3d.push(hole3d);
                }
                triangles.push(...this._triangulate(polygon2d, polygon3d, polygonHoles2d, polygonHoles3d));
            }
            return triangles;
        }
    }

    /**
     * @class RectGeometry
     *
     * @classdesc Represents a rectangle geometry in the 2D basic image coordinate system.
     *
     * @example
     * ```js
     * var basicRect = [0.5, 0.3, 0.7, 0.4];
     * var rectGeometry = new RectGeometry(basicRect);
     * ```
     */
    class RectGeometry extends VertexGeometry {
        /**
         * Create a rectangle geometry.
         *
         * @constructor
         * @param {Array<number>} rect - An array representing the top-left and bottom-right
         * corners of the rectangle in basic coordinates. Ordered according to [x0, y0, x1, y1].
         *
         * @throws {GeometryTagError} Rectangle coordinates must be valid basic coordinates.
         */
        constructor(rect) {
            super();
            if (rect.length !== 4) {
                throw new GeometryTagError("Rectangle needs to have four values.");
            }
            if (rect[1] > rect[3]) {
                throw new GeometryTagError("Basic Y coordinates values can not be inverted.");
            }
            for (let coord of rect) {
                if (coord < 0 || coord > 1) {
                    throw new GeometryTagError("Basic coordinates must be on the interval [0, 1].");
                }
            }
            this._anchorIndex = undefined;
            this._rect = rect.slice(0, 4);
            this._inverted = this._rect[0] > this._rect[2];
        }
        /**
         * Get anchor index property.
         *
         * @returns {number} Index representing the current anchor property if
         * achoring indexing has been initialized. If anchor indexing has not been
         * initialized or has been terminated undefined will be returned.
         * @ignore
         */
        get anchorIndex() {
            return this._anchorIndex;
        }
        /**
         * Get inverted property.
         *
         * @returns {boolean} Boolean determining whether the rect geometry is
         * inverted. For spherical the rect geometrye may be inverted.
         * @ignore
         */
        get inverted() {
            return this._inverted;
        }
        /**
         * Get rect property.
         *
         * @returns {Array<number>} Array representing the top-left and bottom-right
         * corners of the rectangle in basic coordinates.
         */
        get rect() {
            return this._rect;
        }
        /**
         * Initialize anchor indexing to enable setting opposite vertex.
         *
         * @param {number} [index] - The index of the vertex to use as anchor.
         *
         * @throws {GeometryTagError} If anchor indexing has already been initialized.
         * @throws {GeometryTagError} If index is not valid (0 to 3).
         * @ignore
         */
        initializeAnchorIndexing(index) {
            if (this._anchorIndex !== undefined) {
                throw new GeometryTagError("Anchor indexing is already initialized.");
            }
            if (index < 0 || index > 3) {
                throw new GeometryTagError(`Invalid anchor index: ${index}.`);
            }
            this._anchorIndex = index === undefined ? 0 : index;
        }
        /**
         * Terminate anchor indexing to disable setting pposite vertex.
         * @ignore
         */
        terminateAnchorIndexing() {
            this._anchorIndex = undefined;
        }
        /**
         * Set the value of the vertex opposite to the anchor in the polygon
         * representation of the rectangle.
         *
         * @description Setting the opposite vertex may change the anchor index.
         *
         * @param {Array<number>} opposite - The new value of the vertex opposite to the anchor.
         * @param {Transform} transform - The transform of the image related to the rectangle.
         *
         * @throws {GeometryTagError} When anchor indexing has not been initialized.
         * @ignore
         */
        setOppositeVertex2d(opposite, transform) {
            if (this._anchorIndex === undefined) {
                throw new GeometryTagError("Anchor indexing needs to be initialized.");
            }
            const changed = [
                Math.max(0, Math.min(1, opposite[0])),
                Math.max(0, Math.min(1, opposite[1])),
            ];
            const original = this._rect.slice();
            const anchor = this._anchorIndex === 0 ? [original[0], original[3]] :
                this._anchorIndex === 1 ? [original[0], original[1]] :
                    this._anchorIndex === 2 ? [original[2], original[1]] :
                        [original[2], original[3]];
            if (isSpherical(transform.cameraType)) {
                const deltaX = this._anchorIndex < 2 ?
                    changed[0] - original[2] :
                    changed[0] - original[0];
                if (!this._inverted && this._anchorIndex < 2 && changed[0] < 0.25 && original[2] > 0.75 && deltaX < -0.5) {
                    // right side passes boundary rightward
                    this._inverted = true;
                    this._anchorIndex = anchor[1] > changed[1] ? 0 : 1;
                }
                else if (!this._inverted && this._anchorIndex >= 2 && changed[0] < 0.25 && original[2] > 0.75 && deltaX < -0.5) {
                    // left side passes right side and boundary rightward
                    this._inverted = true;
                    this._anchorIndex = anchor[1] > changed[1] ? 0 : 1;
                }
                else if (this._inverted && this._anchorIndex >= 2 && changed[0] < 0.25 && original[0] > 0.75 && deltaX < -0.5) {
                    this._inverted = false;
                    if (anchor[0] > changed[0]) {
                        // left side passes boundary rightward
                        this._anchorIndex = anchor[1] > changed[1] ? 3 : 2;
                    }
                    else {
                        // left side passes right side and boundary rightward
                        this._anchorIndex = anchor[1] > changed[1] ? 0 : 1;
                    }
                }
                else if (!this._inverted && this._anchorIndex >= 2 && changed[0] > 0.75 && original[0] < 0.25 && deltaX > 0.5) {
                    // left side passes boundary leftward
                    this._inverted = true;
                    this._anchorIndex = anchor[1] > changed[1] ? 3 : 2;
                }
                else if (!this._inverted && this._anchorIndex < 2 && changed[0] > 0.75 && original[0] < 0.25 && deltaX > 0.5) {
                    // right side passes left side and boundary leftward
                    this._inverted = true;
                    this._anchorIndex = anchor[1] > changed[1] ? 3 : 2;
                }
                else if (this._inverted && this._anchorIndex < 2 && changed[0] > 0.75 && original[2] < 0.25 && deltaX > 0.5) {
                    this._inverted = false;
                    if (anchor[0] > changed[0]) {
                        // right side passes boundary leftward
                        this._anchorIndex = anchor[1] > changed[1] ? 3 : 2;
                    }
                    else {
                        // right side passes left side and boundary leftward
                        this._anchorIndex = anchor[1] > changed[1] ? 0 : 1;
                    }
                }
                else if (this._inverted && this._anchorIndex < 2 && changed[0] > original[0]) {
                    // inverted and right side passes left side completing a loop
                    this._inverted = false;
                    this._anchorIndex = anchor[1] > changed[1] ? 0 : 1;
                }
                else if (this._inverted && this._anchorIndex >= 2 && changed[0] < original[2]) {
                    // inverted and left side passes right side completing a loop
                    this._inverted = false;
                    this._anchorIndex = anchor[1] > changed[1] ? 3 : 2;
                }
                else if (this._inverted) {
                    // if still inverted only top and bottom can switch
                    if (this._anchorIndex < 2) {
                        this._anchorIndex = anchor[1] > changed[1] ? 0 : 1;
                    }
                    else {
                        this._anchorIndex = anchor[1] > changed[1] ? 3 : 2;
                    }
                }
                else {
                    // if still not inverted treat as non spherical
                    if (anchor[0] <= changed[0] && anchor[1] > changed[1]) {
                        this._anchorIndex = 0;
                    }
                    else if (anchor[0] <= changed[0] && anchor[1] <= changed[1]) {
                        this._anchorIndex = 1;
                    }
                    else if (anchor[0] > changed[0] && anchor[1] <= changed[1]) {
                        this._anchorIndex = 2;
                    }
                    else {
                        this._anchorIndex = 3;
                    }
                }
                const rect = [];
                if (this._anchorIndex === 0) {
                    rect[0] = anchor[0];
                    rect[1] = changed[1];
                    rect[2] = changed[0];
                    rect[3] = anchor[1];
                }
                else if (this._anchorIndex === 1) {
                    rect[0] = anchor[0];
                    rect[1] = anchor[1];
                    rect[2] = changed[0];
                    rect[3] = changed[1];
                }
                else if (this._anchorIndex === 2) {
                    rect[0] = changed[0];
                    rect[1] = anchor[1];
                    rect[2] = anchor[0];
                    rect[3] = changed[1];
                }
                else {
                    rect[0] = changed[0];
                    rect[1] = changed[1];
                    rect[2] = anchor[0];
                    rect[3] = anchor[1];
                }
                if (!this._inverted && rect[0] > rect[2] ||
                    this._inverted && rect[0] < rect[2]) {
                    rect[0] = original[0];
                    rect[2] = original[2];
                }
                if (rect[1] > rect[3]) {
                    rect[1] = original[1];
                    rect[3] = original[3];
                }
                this._rect[0] = rect[0];
                this._rect[1] = rect[1];
                this._rect[2] = rect[2];
                this._rect[3] = rect[3];
            }
            else {
                if (anchor[0] <= changed[0] && anchor[1] > changed[1]) {
                    this._anchorIndex = 0;
                }
                else if (anchor[0] <= changed[0] && anchor[1] <= changed[1]) {
                    this._anchorIndex = 1;
                }
                else if (anchor[0] > changed[0] && anchor[1] <= changed[1]) {
                    this._anchorIndex = 2;
                }
                else {
                    this._anchorIndex = 3;
                }
                const rect = [];
                if (this._anchorIndex === 0) {
                    rect[0] = anchor[0];
                    rect[1] = changed[1];
                    rect[2] = changed[0];
                    rect[3] = anchor[1];
                }
                else if (this._anchorIndex === 1) {
                    rect[0] = anchor[0];
                    rect[1] = anchor[1];
                    rect[2] = changed[0];
                    rect[3] = changed[1];
                }
                else if (this._anchorIndex === 2) {
                    rect[0] = changed[0];
                    rect[1] = anchor[1];
                    rect[2] = anchor[0];
                    rect[3] = changed[1];
                }
                else {
                    rect[0] = changed[0];
                    rect[1] = changed[1];
                    rect[2] = anchor[0];
                    rect[3] = anchor[1];
                }
                if (rect[0] > rect[2]) {
                    rect[0] = original[0];
                    rect[2] = original[2];
                }
                if (rect[1] > rect[3]) {
                    rect[1] = original[1];
                    rect[3] = original[3];
                }
                this._rect[0] = rect[0];
                this._rect[1] = rect[1];
                this._rect[2] = rect[2];
                this._rect[3] = rect[3];
            }
            this._notifyChanged$.next(this);
        }
        /**
         * Set the value of a vertex in the polygon representation of the rectangle.
         *
         * @description The polygon is defined to have the first vertex at the
         * bottom-left corner with the rest of the vertices following in clockwise order.
         *
         * @param {number} index - The index of the vertex to be set.
         * @param {Array<number>} value - The new value of the vertex.
         * @param {Transform} transform - The transform of the image related to the rectangle.
         * @ignore
         */
        setVertex2d(index, value, transform) {
            let original = this._rect.slice();
            let changed = [
                Math.max(0, Math.min(1, value[0])),
                Math.max(0, Math.min(1, value[1])),
            ];
            let rect = [];
            if (index === 0) {
                rect[0] = changed[0];
                rect[1] = original[1];
                rect[2] = original[2];
                rect[3] = changed[1];
            }
            else if (index === 1) {
                rect[0] = changed[0];
                rect[1] = changed[1];
                rect[2] = original[2];
                rect[3] = original[3];
            }
            else if (index === 2) {
                rect[0] = original[0];
                rect[1] = changed[1];
                rect[2] = changed[0];
                rect[3] = original[3];
            }
            else if (index === 3) {
                rect[0] = original[0];
                rect[1] = original[1];
                rect[2] = changed[0];
                rect[3] = changed[1];
            }
            if (isSpherical(transform.cameraType)) {
                let passingBoundaryLeftward = index < 2 && changed[0] > 0.75 && original[0] < 0.25 ||
                    index >= 2 && this._inverted && changed[0] > 0.75 && original[2] < 0.25;
                let passingBoundaryRightward = index < 2 && this._inverted && changed[0] < 0.25 && original[0] > 0.75 ||
                    index >= 2 && changed[0] < 0.25 && original[2] > 0.75;
                if (passingBoundaryLeftward || passingBoundaryRightward) {
                    this._inverted = !this._inverted;
                }
                else {
                    if (rect[0] - original[0] < -0.25) {
                        rect[0] = original[0];
                    }
                    if (rect[2] - original[2] > 0.25) {
                        rect[2] = original[2];
                    }
                }
                if (!this._inverted && rect[0] > rect[2] ||
                    this._inverted && rect[0] < rect[2]) {
                    rect[0] = original[0];
                    rect[2] = original[2];
                }
            }
            else {
                if (rect[0] > rect[2]) {
                    rect[0] = original[0];
                    rect[2] = original[2];
                }
            }
            if (rect[1] > rect[3]) {
                rect[1] = original[1];
                rect[3] = original[3];
            }
            this._rect[0] = rect[0];
            this._rect[1] = rect[1];
            this._rect[2] = rect[2];
            this._rect[3] = rect[3];
            this._notifyChanged$.next(this);
        }
        /** @ignore */
        setCentroid2d(value, transform) {
            let original = this._rect.slice();
            let x0 = original[0];
            let x1 = this._inverted ? original[2] + 1 : original[2];
            let y0 = original[1];
            let y1 = original[3];
            let centerX = x0 + (x1 - x0) / 2;
            let centerY = y0 + (y1 - y0) / 2;
            let translationX = 0;
            if (isSpherical(transform.cameraType)) {
                translationX = this._inverted ? value[0] + 1 - centerX : value[0] - centerX;
            }
            else {
                let minTranslationX = -x0;
                let maxTranslationX = 1 - x1;
                translationX = Math.max(minTranslationX, Math.min(maxTranslationX, value[0] - centerX));
            }
            let minTranslationY = -y0;
            let maxTranslationY = 1 - y1;
            let translationY = Math.max(minTranslationY, Math.min(maxTranslationY, value[1] - centerY));
            this._rect[0] = original[0] + translationX;
            this._rect[1] = original[1] + translationY;
            this._rect[2] = original[2] + translationX;
            this._rect[3] = original[3] + translationY;
            if (this._rect[0] < 0) {
                this._rect[0] += 1;
                this._inverted = !this._inverted;
            }
            else if (this._rect[0] > 1) {
                this._rect[0] -= 1;
                this._inverted = !this._inverted;
            }
            if (this._rect[2] < 0) {
                this._rect[2] += 1;
                this._inverted = !this._inverted;
            }
            else if (this._rect[2] > 1) {
                this._rect[2] -= 1;
                this._inverted = !this._inverted;
            }
            this._notifyChanged$.next(this);
        }
        /**
         * Get the 3D coordinates for the vertices of the rectangle with
         * interpolated points along the lines.
         *
         * @param {Transform} transform - The transform of the image related to
         * the rectangle.
         * @returns {Array<Array<number>>} Polygon array of 3D world coordinates
         * representing the rectangle.
         * @ignore
         */
        getPoints3d(transform) {
            return this._getPoints2d()
                .map((point) => {
                return transform.unprojectBasic(point, 200);
            });
        }
        /**
         * Get the coordinates of a vertex from the polygon representation of the geometry.
         *
         * @description The first vertex represents the bottom-left corner with the rest of
         * the vertices following in clockwise order. The method shifts the right side
         * coordinates of the rectangle by one unit to ensure that the vertices are ordered
         * clockwise.
         *
         * @param {number} index - Vertex index.
         * @returns {Array<number>} Array representing the 2D basic coordinates of the vertex.
         * @ignore
         */
        getVertex2d(index) {
            return this._rectToVertices2d(this._rect)[index];
        }
        /**
         * Get the coordinates of a vertex from the polygon representation of the geometry.
         *
         * @description The first vertex represents the bottom-left corner with the rest of
         * the vertices following in clockwise order. The coordinates will not be shifted
         * so they may not appear in clockwise order when layed out on the plane.
         *
         * @param {number} index - Vertex index.
         * @returns {Array<number>} Array representing the 2D basic coordinates of the vertex.
         * @ignore
         */
        getNonAdjustedVertex2d(index) {
            return this._rectToNonAdjustedVertices2d(this._rect)[index];
        }
        /**
         * Get a vertex from the polygon representation of the 3D coordinates for the
         * vertices of the geometry.
         *
         * @description The first vertex represents the bottom-left corner with the rest of
         * the vertices following in clockwise order.
         *
         * @param {number} index - Vertex index.
         * @param {Transform} transform - The transform of the image related to the geometry.
         * @returns {Array<Array<number>>} Polygon array of 3D world coordinates representing
         * the vertices of the geometry.
         * @ignore
         */
        getVertex3d(index, transform) {
            return transform.unprojectBasic(this._rectToVertices2d(this._rect)[index], 200);
        }
        /**
         * Get a polygon representation of the 2D basic coordinates for the vertices of the rectangle.
         *
         * @description The first vertex represents the bottom-left corner with the rest of
         * the vertices following in clockwise order.
         *
         * @returns {Array<Array<number>>} Polygon array of 2D basic coordinates representing
         * the rectangle vertices.
         * @ignore
         */
        getVertices2d() {
            return this._rectToVertices2d(this._rect);
        }
        /**
         * Get a polygon representation of the 3D coordinates for the vertices of the rectangle.
         *
         * @description The first vertex represents the bottom-left corner with the rest of
         * the vertices following in clockwise order.
         *
         * @param {Transform} transform - The transform of the image related to the rectangle.
         * @returns {Array<Array<number>>} Polygon array of 3D world coordinates representing
         * the rectangle vertices.
         * @ignore
         */
        getVertices3d(transform) {
            return this._rectToVertices2d(this._rect)
                .map((vertex) => {
                return transform.unprojectBasic(vertex, 200);
            });
        }
        /** @ignore */
        getCentroid2d() {
            const rect = this._rect;
            const x0 = rect[0];
            const x1 = this._inverted ? rect[2] + 1 : rect[2];
            const y0 = rect[1];
            const y1 = rect[3];
            const centroidX = (x0 + x1) / 2;
            const centroidY = (y0 + y1) / 2;
            return [centroidX, centroidY];
        }
        /** @ignore */
        getCentroid3d(transform) {
            const centroid2d = this.getCentroid2d();
            return transform.unprojectBasic(centroid2d, 200);
        }
        /**
         * @ignore
         */
        getPoleOfInaccessibility2d() {
            return this._getPoleOfInaccessibility2d(this._rectToVertices2d(this._rect));
        }
        /** @ignore */
        getPoleOfInaccessibility3d(transform) {
            let pole2d = this._getPoleOfInaccessibility2d(this._rectToVertices2d(this._rect));
            return transform.unprojectBasic(pole2d, 200);
        }
        /** @ignore */
        getTriangles3d(transform) {
            return isSpherical(transform.cameraType) ?
                [] :
                this._triangulate(this._project(this._getPoints2d(), transform), this.getPoints3d(transform));
        }
        /**
         * Check if a particular bottom-right value is valid according to the current
         * rectangle coordinates.
         *
         * @param {Array<number>} bottomRight - The bottom-right coordinates to validate
         * @returns {boolean} Value indicating whether the provided bottom-right coordinates
         * are valid.
         * @ignore
         */
        validate(bottomRight) {
            let rect = this._rect;
            if (!this._inverted && bottomRight[0] < rect[0] ||
                bottomRight[0] - rect[2] > 0.25 ||
                bottomRight[1] < rect[1]) {
                return false;
            }
            return true;
        }
        /**
         * Get the 2D coordinates for the vertices of the rectangle with
         * interpolated points along the lines.
         *
         * @returns {Array<Array<number>>} Polygon array of 2D basic coordinates
         * representing the rectangle.
         */
        _getPoints2d() {
            let vertices2d = this._rectToVertices2d(this._rect);
            let sides = vertices2d.length - 1;
            let sections = 10;
            let points2d = [];
            for (let i = 0; i < sides; ++i) {
                let startX = vertices2d[i][0];
                let startY = vertices2d[i][1];
                let endX = vertices2d[i + 1][0];
                let endY = vertices2d[i + 1][1];
                let intervalX = (endX - startX) / (sections - 1);
                let intervalY = (endY - startY) / (sections - 1);
                for (let j = 0; j < sections; ++j) {
                    let point = [
                        startX + j * intervalX,
                        startY + j * intervalY,
                    ];
                    points2d.push(point);
                }
            }
            return points2d;
        }
        /**
         * Convert the top-left, bottom-right representation of a rectangle to a polygon
         * representation of the vertices starting at the bottom-left corner going
         * clockwise.
         *
         * @description The method shifts the right side coordinates of the rectangle
         * by one unit to ensure that the vertices are ordered clockwise.
         *
         * @param {Array<number>} rect - Top-left, bottom-right representation of a
         * rectangle.
         * @returns {Array<Array<number>>} Polygon representation of the vertices of the
         * rectangle.
         */
        _rectToVertices2d(rect) {
            return [
                [rect[0], rect[3]],
                [rect[0], rect[1]],
                [this._inverted ? rect[2] + 1 : rect[2], rect[1]],
                [this._inverted ? rect[2] + 1 : rect[2], rect[3]],
                [rect[0], rect[3]],
            ];
        }
        /**
         * Convert the top-left, bottom-right representation of a rectangle to a polygon
         * representation of the vertices starting at the bottom-left corner going
         * clockwise.
         *
         * @description The first vertex represents the bottom-left corner with the rest of
         * the vertices following in clockwise order. The coordinates will not be shifted
         * to ensure that the vertices are ordered clockwise when layed out on the plane.
         *
         * @param {Array<number>} rect - Top-left, bottom-right representation of a
         * rectangle.
         * @returns {Array<Array<number>>} Polygon representation of the vertices of the
         * rectangle.
         */
        _rectToNonAdjustedVertices2d(rect) {
            return [
                [rect[0], rect[3]],
                [rect[0], rect[1]],
                [rect[2], rect[1]],
                [rect[2], rect[3]],
                [rect[0], rect[3]],
            ];
        }
    }

    class ExtremePointCreateTag extends CreateTag {
        constructor(geometry, options, transform, viewportCoords) {
            super(geometry, transform, viewportCoords);
            this._options = {
                color: options.color == null ? 0xFFFFFF : options.color,
                indicateCompleter: options.indicateCompleter == null ? true : options.indicateCompleter,
            };
            this._rectGeometry = new RectGeometry(this._geometry.getRect2d(transform));
            this._createGlObjects();
        }
        create() {
            if (this._geometry.points.length < 3) {
                return;
            }
            this._geometry.removePoint2d(this._geometry.points.length - 1);
            this._created$.next(this);
        }
        dispose() {
            super.dispose();
            this._disposeObjects();
        }
        getDOMObjects(camera, size) {
            const container = {
                offsetHeight: size.height, offsetWidth: size.width,
            };
            const vNodes = [];
            const points2d = this._geometry.getPoints2d();
            const length = points2d.length;
            for (let index = 0; index < length - 1; index++) {
                const nonModifiedIndex = index;
                const [pointX, pointY] = points2d[index];
                const pointCanvas = this._viewportCoords.basicToCanvasSafe(pointX, pointY, container, this._transform, camera);
                if (!pointCanvas) {
                    continue;
                }
                const abort = (e) => {
                    e.stopPropagation();
                    this._aborted$.next(this);
                };
                const remove = (e) => {
                    e.stopPropagation();
                    this._geometry.removePoint2d(nonModifiedIndex);
                };
                const transform = this._canvasToTransform(pointCanvas);
                const completerProperties = {
                    onclick: index === 0 && length < 3 ? abort : remove,
                    style: { transform: transform },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-interactor", completerProperties, []));
                const background = this._colorToBackground(this._options.color);
                const pointProperties = {
                    style: {
                        background: background,
                        transform: transform,
                    },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-vertex", pointProperties, []));
            }
            if (length > 2 && this._options.indicateCompleter === true) {
                const [centroidX, centroidY] = this._geometry.getCentroid2d(this._transform);
                const centroidCanvas = this._viewportCoords.basicToCanvasSafe(centroidX, centroidY, container, this._transform, camera);
                if (!!centroidCanvas) {
                    const complete = (e) => {
                        e.stopPropagation();
                        this._geometry.removePoint2d(this._geometry.points.length - 1);
                        this._created$.next(this);
                    };
                    const transform = this._canvasToTransform(centroidCanvas);
                    const completerProperties = {
                        onclick: complete,
                        style: { transform: transform },
                    };
                    vNodes.push(virtualDom.h("div.mapillary-tag-completer.mapillary-tag-larger", completerProperties, []));
                    const pointProperties = {
                        style: {
                            background: this._colorToBackground(this._options.color),
                            transform: transform,
                        },
                    };
                    vNodes.push(virtualDom.h("div.mapillary-tag-vertex.mapillary-tag-larger", pointProperties, []));
                    const dotProperties = {
                        style: {
                            transform: transform,
                        },
                    };
                    vNodes.push(virtualDom.h("div.mapillary-tag-dot", dotProperties, []));
                }
            }
            return vNodes;
        }
        _onGeometryChanged() {
            this._disposeObjects();
            this._rectGeometry = new RectGeometry(this._geometry.getRect2d(this._transform));
            this._createGlObjects();
        }
        _createGlObjects() {
            this._glObjects = [];
            const polygon3d = this._rectGeometry.getPoints3d(this._transform);
            this._outline = this._createOutine(polygon3d, this._options.color);
            this._glObjects.push(this._outline);
        }
        _disposeObjects() {
            this._disposeLine(this._outline);
            this._outline = null;
            this._glObjects = null;
        }
    }

    /**
     * @class PolygonGeometry
     *
     * @classdesc Represents a polygon geometry in the 2D basic image coordinate system.
     * All polygons and holes provided to the constructor needs to be closed.
     *
     * @example
     * ```js
     * var basicPolygon = [[0.5, 0.3], [0.7, 0.3], [0.6, 0.5], [0.5, 0.3]];
     * var polygonGeometry = new PolygonGeometry(basicPolygon);
     * ```
     */
    class PolygonGeometry extends VertexGeometry {
        /**
         * Create a polygon geometry.
         *
         * @constructor
         * @param {Array<Array<number>>} polygon - Array of polygon vertices. Must be closed.
         * @param {Array<Array<Array<number>>>} [holes] - Array of arrays of hole vertices.
         * Each array of holes vertices must be closed.
         *
         * @throws {GeometryTagError} Polygon coordinates must be valid basic coordinates.
         */
        constructor(polygon, holes) {
            super();
            let polygonLength = polygon.length;
            if (polygonLength < 3) {
                throw new GeometryTagError("A polygon must have three or more positions.");
            }
            if (polygon[0][0] !== polygon[polygonLength - 1][0] ||
                polygon[0][1] !== polygon[polygonLength - 1][1]) {
                throw new GeometryTagError("First and last positions must be equivalent.");
            }
            this._polygon = [];
            for (let vertex of polygon) {
                if (vertex[0] < 0 || vertex[0] > 1 ||
                    vertex[1] < 0 || vertex[1] > 1) {
                    throw new GeometryTagError("Basic coordinates of polygon must be on the interval [0, 1].");
                }
                this._polygon.push(vertex.slice());
            }
            this._holes = [];
            if (holes == null) {
                return;
            }
            for (let i = 0; i < holes.length; i++) {
                let hole = holes[i];
                let holeLength = hole.length;
                if (holeLength < 3) {
                    throw new GeometryTagError("A polygon hole must have three or more positions.");
                }
                if (hole[0][0] !== hole[holeLength - 1][0] ||
                    hole[0][1] !== hole[holeLength - 1][1]) {
                    throw new GeometryTagError("First and last positions of hole must be equivalent.");
                }
                this._holes.push([]);
                for (let vertex of hole) {
                    if (vertex[0] < 0 || vertex[0] > 1 ||
                        vertex[1] < 0 || vertex[1] > 1) {
                        throw new GeometryTagError("Basic coordinates of hole must be on the interval [0, 1].");
                    }
                    this._holes[i].push(vertex.slice());
                }
            }
        }
        /**
         * Get polygon property.
         * @returns {Array<Array<number>>} Closed 2d polygon.
         */
        get polygon() {
            return this._polygon;
        }
        /**
         * Get holes property.
         * @returns {Array<Array<Array<number>>>} Holes of 2d polygon.
         */
        get holes() {
            return this._holes;
        }
        /**
         * Add a vertex to the polygon by appending it after the last vertex.
         *
         * @param {Array<number>} vertex - Vertex to add.
         * @ignore
         */
        addVertex2d(vertex) {
            let clamped = [
                Math.max(0, Math.min(1, vertex[0])),
                Math.max(0, Math.min(1, vertex[1])),
            ];
            this._polygon.splice(this._polygon.length - 1, 0, clamped);
            this._notifyChanged$.next(this);
        }
        /**
         * Get the coordinates of a vertex from the polygon representation of the geometry.
         *
         * @param {number} index - Vertex index.
         * @returns {Array<number>} Array representing the 2D basic coordinates of the vertex.
         * @ignore
         */
        getVertex2d(index) {
            return this._polygon[index].slice();
        }
        /**
         * Remove a vertex from the polygon.
         *
         * @param {number} index - The index of the vertex to remove.
         * @ignore
         */
        removeVertex2d(index) {
            if (index < 0 ||
                index >= this._polygon.length ||
                this._polygon.length < 4) {
                throw new GeometryTagError("Index for removed vertex must be valid.");
            }
            if (index > 0 && index < this._polygon.length - 1) {
                this._polygon.splice(index, 1);
            }
            else {
                this._polygon.splice(0, 1);
                this._polygon.pop();
                let closing = this._polygon[0].slice();
                this._polygon.push(closing);
            }
            this._notifyChanged$.next(this);
        }
        /** @ignore */
        setVertex2d(index, value, transform) {
            let changed = [
                Math.max(0, Math.min(1, value[0])),
                Math.max(0, Math.min(1, value[1])),
            ];
            if (index === 0 || index === this._polygon.length - 1) {
                this._polygon[0] = changed.slice();
                this._polygon[this._polygon.length - 1] = changed.slice();
            }
            else {
                this._polygon[index] = changed.slice();
            }
            this._notifyChanged$.next(this);
        }
        /** @ignore */
        setCentroid2d(value, transform) {
            let xs = this._polygon.map((point) => { return point[0]; });
            let ys = this._polygon.map((point) => { return point[1]; });
            let minX = Math.min.apply(Math, xs);
            let maxX = Math.max.apply(Math, xs);
            let minY = Math.min.apply(Math, ys);
            let maxY = Math.max.apply(Math, ys);
            let centroid = this.getCentroid2d();
            let minTranslationX = -minX;
            let maxTranslationX = 1 - maxX;
            let minTranslationY = -minY;
            let maxTranslationY = 1 - maxY;
            let translationX = Math.max(minTranslationX, Math.min(maxTranslationX, value[0] - centroid[0]));
            let translationY = Math.max(minTranslationY, Math.min(maxTranslationY, value[1] - centroid[1]));
            for (let point of this._polygon) {
                point[0] += translationX;
                point[1] += translationY;
            }
            this._notifyChanged$.next(this);
        }
        /** @ignore */
        getPoints3d(transform) {
            return this._getPoints3d(this._subsample(this._polygon), transform);
        }
        /** @ignore */
        getVertex3d(index, transform) {
            return transform.unprojectBasic(this._polygon[index], 200);
        }
        /** @ignore */
        getVertices2d() {
            return this._polygon.slice();
        }
        /** @ignore */
        getVertices3d(transform) {
            return this._getPoints3d(this._polygon, transform);
        }
        /**
         * Get a polygon representation of the 3D coordinates for the vertices of each hole
         * of the geometry. Line segments between vertices will possibly be subsampled
         * resulting in a larger number of points than the total number of vertices.
         *
         * @param {Transform} transform - The transform of the image related to the geometry.
         * @returns {Array<Array<Array<number>>>} Array of hole polygons in 3D world coordinates
         * representing the vertices of each hole of the geometry.
         * @ignore
         */
        getHolePoints3d(transform) {
            return this._holes
                .map((hole2d) => {
                return this._getPoints3d(this._subsample(hole2d), transform);
            });
        }
        /**
         * Get a polygon representation of the 3D coordinates for the vertices of each hole
         * of the geometry.
         *
         * @param {Transform} transform - The transform of the image related to the geometry.
         * @returns {Array<Array<Array<number>>>} Array of hole polygons in 3D world coordinates
         * representing the vertices of each hole of the geometry.
         * @ignore
         */
        getHoleVertices3d(transform) {
            return this._holes
                .map((hole2d) => {
                return this._getPoints3d(hole2d, transform);
            });
        }
        /** @ignore */
        getCentroid2d() {
            let polygon = this._polygon;
            let area = 0;
            let centroidX = 0;
            let centroidY = 0;
            for (let i = 0; i < polygon.length - 1; i++) {
                let xi = polygon[i][0];
                let yi = polygon[i][1];
                let xi1 = polygon[i + 1][0];
                let yi1 = polygon[i + 1][1];
                let a = xi * yi1 - xi1 * yi;
                area += a;
                centroidX += (xi + xi1) * a;
                centroidY += (yi + yi1) * a;
            }
            area /= 2;
            centroidX /= 6 * area;
            centroidY /= 6 * area;
            return [centroidX, centroidY];
        }
        /** @ignore */
        getCentroid3d(transform) {
            let centroid2d = this.getCentroid2d();
            return transform.unprojectBasic(centroid2d, 200);
        }
        /** @ignore */
        get3dDomainTriangles3d(transform) {
            return this._triangulate(this._project(this._polygon, transform), this.getVertices3d(transform), this._holes
                .map((hole2d) => {
                return this._project(hole2d, transform);
            }), this.getHoleVertices3d(transform));
        }
        /** @ignore */
        getTriangles3d(transform) {
            if (isSpherical(transform.cameraType)) {
                return this._triangulateSpherical(this._polygon.slice(), this.holes.slice(), transform);
            }
            const points2d = this._project(this._subsample(this._polygon), transform);
            const points3d = this.getPoints3d(transform);
            const holes2d = this._holes
                .map((hole) => {
                return this._project(this._subsample(hole), transform);
            });
            const holes3d = this.getHolePoints3d(transform);
            return this._triangulate(points2d, points3d, holes2d, holes3d);
        }
        /** @ignore */
        getPoleOfInaccessibility2d() {
            return this._getPoleOfInaccessibility2d(this._polygon.slice());
        }
        /** @ignore */
        getPoleOfInaccessibility3d(transform) {
            let pole2d = this._getPoleOfInaccessibility2d(this._polygon.slice());
            return transform.unprojectBasic(pole2d, 200);
        }
        _getPoints3d(points2d, transform) {
            return points2d
                .map((point) => {
                return transform.unprojectBasic(point, 200);
            });
        }
    }

    class OutlineCreateTag extends CreateTag {
        constructor(geometry, options, transform, viewportCoords) {
            super(geometry, transform, viewportCoords);
            this._options = { color: options.color == null ? 0xFFFFFF : options.color };
            this._createGlObjects();
        }
        create() {
            if (this._geometry instanceof RectGeometry) {
                this._created$.next(this);
            }
            else if (this._geometry instanceof PolygonGeometry) {
                const polygonGeometry = this._geometry;
                polygonGeometry.removeVertex2d(polygonGeometry.polygon.length - 2);
                this._created$.next(this);
            }
        }
        dispose() {
            super.dispose();
            this._disposeLine(this._outline);
            this._disposeObjects();
        }
        getDOMObjects(camera, size) {
            const vNodes = [];
            const container = {
                offsetHeight: size.height, offsetWidth: size.width,
            };
            const abort = (e) => {
                e.stopPropagation();
                this._aborted$.next(this);
            };
            if (this._geometry instanceof RectGeometry) {
                const anchorIndex = this._geometry.anchorIndex;
                const vertexIndex = anchorIndex === undefined ? 1 : anchorIndex;
                const [basicX, basicY] = this._geometry.getVertex2d(vertexIndex);
                const canvasPoint = this._viewportCoords.basicToCanvasSafe(basicX, basicY, container, this._transform, camera);
                if (canvasPoint != null) {
                    const background = this._colorToBackground(this._options.color);
                    const transform = this._canvasToTransform(canvasPoint);
                    const pointProperties = {
                        style: { background: background, transform: transform },
                    };
                    const completerProperties = {
                        onclick: abort,
                        style: { transform: transform },
                    };
                    vNodes.push(virtualDom.h("div.mapillary-tag-interactor", completerProperties, []));
                    vNodes.push(virtualDom.h("div.mapillary-tag-vertex", pointProperties, []));
                }
            }
            else if (this._geometry instanceof PolygonGeometry) {
                const polygonGeometry = this._geometry;
                const [firstVertexBasicX, firstVertexBasicY] = polygonGeometry.getVertex2d(0);
                const firstVertexCanvas = this._viewportCoords.basicToCanvasSafe(firstVertexBasicX, firstVertexBasicY, container, this._transform, camera);
                if (firstVertexCanvas != null) {
                    const firstOnclick = polygonGeometry.polygon.length > 4 ?
                        (e) => {
                            e.stopPropagation();
                            polygonGeometry.removeVertex2d(polygonGeometry.polygon.length - 2);
                            this._created$.next(this);
                        } :
                        abort;
                    const transform = this._canvasToTransform(firstVertexCanvas);
                    const completerProperties = {
                        onclick: firstOnclick,
                        style: { transform: transform },
                    };
                    const firstClass = polygonGeometry.polygon.length > 4 ?
                        "mapillary-tag-completer" :
                        "mapillary-tag-interactor";
                    vNodes.push(virtualDom.h("div." + firstClass, completerProperties, []));
                }
                if (polygonGeometry.polygon.length > 3) {
                    const [lastVertexBasicX, lastVertexBasicY] = polygonGeometry.getVertex2d(polygonGeometry.polygon.length - 3);
                    const lastVertexCanvas = this._viewportCoords.basicToCanvasSafe(lastVertexBasicX, lastVertexBasicY, container, this._transform, camera);
                    if (lastVertexCanvas != null) {
                        const remove = (e) => {
                            e.stopPropagation();
                            polygonGeometry.removeVertex2d(polygonGeometry.polygon.length - 3);
                        };
                        const transform = this._canvasToTransform(lastVertexCanvas);
                        const completerProperties = {
                            onclick: remove,
                            style: { transform: transform },
                        };
                        vNodes.push(virtualDom.h("div.mapillary-tag-interactor", completerProperties, []));
                    }
                }
                const verticesBasic = polygonGeometry.polygon.slice();
                verticesBasic.splice(-2, 2);
                for (const vertexBasic of verticesBasic) {
                    const vertexCanvas = this._viewportCoords.basicToCanvasSafe(vertexBasic[0], vertexBasic[1], container, this._transform, camera);
                    if (vertexCanvas != null) {
                        const background = this._colorToBackground(this._options.color);
                        const transform = this._canvasToTransform(vertexCanvas);
                        const pointProperties = {
                            style: {
                                background: background,
                                transform: transform,
                            },
                        };
                        vNodes.push(virtualDom.h("div.mapillary-tag-vertex", pointProperties, []));
                    }
                }
            }
            return vNodes;
        }
        addPoint(point) {
            if (this._geometry instanceof RectGeometry) {
                const rectGeometry = this._geometry;
                if (!rectGeometry.validate(point)) {
                    return;
                }
                this._created$.next(this);
            }
            else if (this._geometry instanceof PolygonGeometry) {
                const polygonGeometry = this._geometry;
                polygonGeometry.addVertex2d(point);
            }
        }
        _onGeometryChanged() {
            this._disposeLine(this._outline);
            this._disposeObjects();
            this._createGlObjects();
        }
        _disposeObjects() {
            this._outline = null;
            this._glObjects = [];
        }
        _createGlObjects() {
            const polygon3d = this._geometry instanceof RectGeometry ?
                this._geometry.getPoints3d(this._transform) :
                this._geometry.getVertices3d(this._transform);
            this._outline = this._createOutine(polygon3d, this._options.color);
            this._glObjects = [this._outline];
        }
    }

    class TagCreator {
        constructor(component, navigator) {
            this._component = component;
            this._navigator = navigator;
            this._tagOperation$ = new Subject();
            this._createPoints$ = new Subject();
            this._createPolygon$ = new Subject();
            this._createRect$ = new Subject();
            this._delete$ = new Subject();
            this._tag$ = this._tagOperation$.pipe(scan((tag, operation) => {
                return operation(tag);
            }, null), share());
            this._replayedTag$ = this._tag$.pipe(publishReplay(1), refCount());
            this._replayedTag$.subscribe();
            this._createPoints$.pipe(withLatestFrom(this._component.configuration$, this._navigator.stateService.currentTransform$), map(([coord, conf, transform]) => {
                return () => {
                    const geometry = new PointsGeometry([
                        [coord[0], coord[1]],
                        [coord[0], coord[1]],
                    ]);
                    return new ExtremePointCreateTag(geometry, {
                        color: conf.createColor,
                        indicateCompleter: conf.indicatePointsCompleter,
                    }, transform);
                };
            }))
                .subscribe(this._tagOperation$);
            this._createRect$.pipe(withLatestFrom(this._component.configuration$, this._navigator.stateService.currentTransform$), map(([coord, conf, transform]) => {
                return () => {
                    const geometry = new RectGeometry([
                        coord[0],
                        coord[1],
                        coord[0],
                        coord[1],
                    ]);
                    return new OutlineCreateTag(geometry, { color: conf.createColor }, transform);
                };
            }))
                .subscribe(this._tagOperation$);
            this._createPolygon$.pipe(withLatestFrom(this._component.configuration$, this._navigator.stateService.currentTransform$), map(([coord, conf, transform]) => {
                return () => {
                    const geometry = new PolygonGeometry([
                        [coord[0], coord[1]],
                        [coord[0], coord[1]],
                        [coord[0], coord[1]],
                    ]);
                    return new OutlineCreateTag(geometry, { color: conf.createColor }, transform);
                };
            }))
                .subscribe(this._tagOperation$);
            this._delete$.pipe(map(() => {
                return () => {
                    return null;
                };
            }))
                .subscribe(this._tagOperation$);
        }
        get createRect$() {
            return this._createRect$;
        }
        get createPolygon$() {
            return this._createPolygon$;
        }
        get createPoints$() {
            return this._createPoints$;
        }
        get delete$() {
            return this._delete$;
        }
        get tag$() {
            return this._tag$;
        }
        get replayedTag$() {
            return this._replayedTag$;
        }
    }

    class TagDOMRenderer {
        render(tags, createTag, atlas, camera, size) {
            let vNodes = [];
            for (const tag of tags) {
                vNodes = vNodes.concat(tag.getDOMObjects(atlas, camera, size));
            }
            if (createTag != null) {
                vNodes = vNodes.concat(createTag.getDOMObjects(camera, size));
            }
            return virtualDom.h("div.mapillary-tag-container", {}, vNodes);
        }
        clear() {
            return virtualDom.h("div", {}, []);
        }
    }

    class TagScene {
        constructor(scene, raycaster) {
            this._createTag = null;
            this._needsRender = false;
            this._raycaster = !!raycaster ? raycaster : new Raycaster();
            this._scene = !!scene ? scene : new Scene();
            this._objectTags = {};
            this._retrievableObjects = [];
            this._tags = {};
        }
        get needsRender() {
            return this._needsRender;
        }
        add(tags) {
            for (let tag of tags) {
                if (tag.tag.id in this._tags) {
                    this._remove(tag.tag.id);
                }
                this._add(tag);
            }
            this._needsRender = true;
        }
        addCreateTag(tag) {
            for (const object of tag.glObjects) {
                this._scene.add(object);
            }
            this._createTag = { tag: tag, objects: tag.glObjects };
            this._needsRender = true;
        }
        clear() {
            for (const id of Object.keys(this._tags)) {
                this._remove(id);
            }
            this._needsRender = false;
        }
        get(id) {
            return this.has(id) ? this._tags[id].tag : undefined;
        }
        has(id) {
            return id in this._tags;
        }
        hasCreateTag() {
            return this._createTag != null;
        }
        intersectObjects([viewportX, viewportY], camera) {
            this._raycaster.setFromCamera(new Vector2(viewportX, viewportY), camera);
            const intersects = this._raycaster.intersectObjects(this._retrievableObjects);
            const intersectedIds = [];
            for (const intersect of intersects) {
                if (intersect.object.uuid in this._objectTags) {
                    intersectedIds.push(this._objectTags[intersect.object.uuid]);
                }
            }
            return intersectedIds;
        }
        remove(ids) {
            for (const id of ids) {
                this._remove(id);
            }
            this._needsRender = true;
        }
        removeAll() {
            for (const id of Object.keys(this._tags)) {
                this._remove(id);
            }
            this._needsRender = true;
        }
        removeCreateTag() {
            if (this._createTag == null) {
                return;
            }
            for (const object of this._createTag.objects) {
                this._scene.remove(object);
            }
            this._createTag.tag.dispose();
            this._createTag = null;
            this._needsRender = true;
        }
        render(perspectiveCamera, renderer) {
            renderer.render(this._scene, perspectiveCamera);
            this._needsRender = false;
        }
        update() {
            this._needsRender = true;
        }
        updateCreateTagObjects(tag) {
            if (this._createTag.tag !== tag) {
                throw new Error("Create tags do not have the same reference.");
            }
            for (let object of this._createTag.objects) {
                this._scene.remove(object);
            }
            for (const object of tag.glObjects) {
                this._scene.add(object);
            }
            this._createTag.objects = tag.glObjects;
            this._needsRender = true;
        }
        updateObjects(tag) {
            const id = tag.tag.id;
            if (this._tags[id].tag !== tag) {
                throw new Error("Tags do not have the same reference.");
            }
            const tagObjects = this._tags[id];
            this._removeObjects(tagObjects);
            delete this._tags[id];
            this._add(tag);
            this._needsRender = true;
        }
        _add(tag) {
            const id = tag.tag.id;
            const tagObjects = { tag: tag, objects: [], retrievableObjects: [] };
            this._tags[id] = tagObjects;
            for (const object of tag.getGLObjects()) {
                tagObjects.objects.push(object);
                this._scene.add(object);
            }
            for (const retrievableObject of tag.getRetrievableObjects()) {
                tagObjects.retrievableObjects.push(retrievableObject);
                this._retrievableObjects.push(retrievableObject);
                this._objectTags[retrievableObject.uuid] = tag.tag.id;
            }
        }
        _remove(id) {
            const tagObjects = this._tags[id];
            this._removeObjects(tagObjects);
            tagObjects.tag.dispose();
            delete this._tags[id];
        }
        _removeObjects(tagObjects) {
            for (const object of tagObjects.objects) {
                this._scene.remove(object);
            }
            for (const retrievableObject of tagObjects.retrievableObjects) {
                const index = this._retrievableObjects.indexOf(retrievableObject);
                if (index !== -1) {
                    this._retrievableObjects.splice(index, 1);
                }
            }
        }
    }

    /**
     * Enumeration for tag modes
     * @enum {number}
     * @readonly
     * @description Modes for the interaction in the tag component.
     */
    exports.TagMode = void 0;
    (function (TagMode) {
        /**
         * Disables creating tags.
         */
        TagMode[TagMode["Default"] = 0] = "Default";
        /**
         * Create a point geometry through a click.
         */
        TagMode[TagMode["CreatePoint"] = 1] = "CreatePoint";
        /**
         * Create a points geometry through clicks.
         */
        TagMode[TagMode["CreatePoints"] = 2] = "CreatePoints";
        /**
         * Create a polygon geometry through clicks.
         */
        TagMode[TagMode["CreatePolygon"] = 3] = "CreatePolygon";
        /**
         * Create a rect geometry through clicks.
         */
        TagMode[TagMode["CreateRect"] = 4] = "CreateRect";
        /**
         * Create a rect geometry through drag.
         *
         * @description Claims the mouse which results in mouse handlers like
         * drag pan and scroll zoom becoming inactive.
         */
        TagMode[TagMode["CreateRectDrag"] = 5] = "CreateRectDrag";
    })(exports.TagMode || (exports.TagMode = {}));

    var TagOperation;
    (function (TagOperation) {
        TagOperation[TagOperation["None"] = 0] = "None";
        TagOperation[TagOperation["Centroid"] = 1] = "Centroid";
        TagOperation[TagOperation["Vertex"] = 2] = "Vertex";
    })(TagOperation || (TagOperation = {}));

    class RenderTag {
        constructor(tag, transform, viewportCoords) {
            this._tag = tag;
            this._transform = transform;
            this._viewportCoords = !!viewportCoords ? viewportCoords : new ViewportCoords();
            this._glObjectsChanged$ = new Subject();
            this._interact$ = new Subject();
        }
        get glObjectsChanged$() {
            return this._glObjectsChanged$;
        }
        get interact$() {
            return this._interact$;
        }
        get tag() {
            return this._tag;
        }
    }

    class OutlineRenderTagBase extends RenderTag {
        constructor(tag, transform) {
            super(tag, transform);
            this._geometryChangedSubscription = this._tag.geometry.changed$
                .subscribe(() => {
                this._onGeometryChanged();
            });
            this._changedSubscription = this._tag.changed$
                .subscribe(() => {
                const glObjectsChanged = this._onTagChanged();
                if (glObjectsChanged) {
                    this._glObjectsChanged$.next(this);
                }
            });
        }
        dispose() {
            this._changedSubscription.unsubscribe();
            this._geometryChangedSubscription.unsubscribe();
        }
        _colorToCss(color) {
            return "#" + ("000000" + color.toString(16)).substr(-6);
        }
        _createFill() {
            let triangles = this._getTriangles();
            let positions = new Float32Array(triangles);
            let geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            geometry.computeBoundingSphere();
            let material = new MeshBasicMaterial({ side: DoubleSide, transparent: true });
            this._updateFillMaterial(material);
            return new Mesh(geometry, material);
        }
        _createLine(points3d) {
            let positions = this._getLinePositions(points3d);
            let geometry = new BufferGeometry();
            geometry.setAttribute("position", new BufferAttribute(positions, 3));
            geometry.computeBoundingSphere();
            let material = new LineBasicMaterial();
            this._updateLineBasicMaterial(material);
            const line = new Line(geometry, material);
            line.renderOrder = 1;
            return line;
        }
        _createOutline() {
            return this._createLine(this._getPoints3d());
        }
        _disposeFill() {
            if (this._fill == null) {
                return;
            }
            this._fill.geometry.dispose();
            this._fill.material.dispose();
            this._fill = null;
        }
        _disposeOutline() {
            if (this._outline == null) {
                return;
            }
            this._outline.geometry.dispose();
            this._outline.material.dispose();
            this._outline = null;
        }
        _getLinePositions(points3d) {
            let length = points3d.length;
            let positions = new Float32Array(length * 3);
            for (let i = 0; i < length; ++i) {
                let index = 3 * i;
                let position = points3d[i];
                positions[index + 0] = position[0];
                positions[index + 1] = position[1];
                positions[index + 2] = position[2];
            }
            return positions;
        }
        _interact(operation, cursor, vertexIndex) {
            return (e) => {
                let offsetX = e.offsetX - e.target.offsetWidth / 2;
                let offsetY = e.offsetY - e.target.offsetHeight / 2;
                this._interact$.next({
                    cursor: cursor,
                    offsetX: offsetX,
                    offsetY: offsetY,
                    operation: operation,
                    tag: this._tag,
                    vertexIndex: vertexIndex,
                });
            };
        }
        _updateFillGeometry() {
            let triangles = this._getTriangles();
            let positions = new Float32Array(triangles);
            let geometry = this._fill.geometry;
            let attribute = geometry.getAttribute("position");
            if (attribute.array.length === positions.length) {
                attribute.set(positions);
                attribute.needsUpdate = true;
            }
            else {
                geometry.deleteAttribute("position");
                geometry.setAttribute("position", new BufferAttribute(positions, 3));
            }
            geometry.computeBoundingSphere();
        }
        _updateLine(line, points3d) {
            let positions = this._getLinePositions(points3d);
            let geometry = line.geometry;
            let attribute = geometry.getAttribute("position");
            attribute.set(positions);
            attribute.needsUpdate = true;
            geometry.computeBoundingSphere();
        }
        _updateOulineGeometry() {
            this._updateLine(this._outline, this._getPoints3d());
        }
    }

    /**
     * @class OutlineRenderTag
     * @classdesc Tag visualizing the properties of an OutlineTag.
     */
    class ExtremePointRenderTag extends OutlineRenderTagBase {
        constructor(tag, transform) {
            super(tag, transform);
            this._rectGeometry = new RectGeometry(this._tag.geometry.getRect2d(transform));
            this._fill = !isSpherical(transform.cameraType) ?
                this._createFill() : null;
            this._outline = this._tag.lineWidth >= 1 ?
                this._createOutline() :
                null;
        }
        dispose() {
            super.dispose();
            this._disposeFill();
            this._disposeOutline();
        }
        getDOMObjects(atlas, camera, size) {
            const vNodes = [];
            const container = {
                offsetHeight: size.height, offsetWidth: size.width,
            };
            if (!this._tag.editable) {
                return vNodes;
            }
            const lineColor = this._colorToCss(this._tag.lineColor);
            const points2d = this._tag.geometry.getPoints2d();
            for (let i = 0; i < points2d.length; i++) {
                const [vertexBasicX, vertexBasicY] = points2d[i];
                const vertexCanvas = this._viewportCoords.basicToCanvasSafe(vertexBasicX, vertexBasicY, container, this._transform, camera);
                if (vertexCanvas == null) {
                    continue;
                }
                const cursor = "crosshair";
                const interact = this._interact(TagOperation.Vertex, cursor, i);
                const vertexCanvasX = Math.round(vertexCanvas[0]);
                const vertexCanvasY = Math.round(vertexCanvas[1]);
                const transform = `translate(-50%, -50%) translate(${vertexCanvasX}px,${vertexCanvasY}px)`;
                const properties = {
                    onpointerdown: interact,
                    style: { background: lineColor, transform: transform, cursor: cursor },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-resizer", properties, []));
                if (!this._tag.indicateVertices) {
                    continue;
                }
                const pointProperties = {
                    style: { background: lineColor, transform: transform },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-vertex", pointProperties, []));
            }
            return vNodes;
        }
        getGLObjects() {
            const glObjects = [];
            if (this._fill != null) {
                glObjects.push(this._fill);
            }
            if (this._outline != null) {
                glObjects.push(this._outline);
            }
            return glObjects;
        }
        getRetrievableObjects() {
            return this._fill != null ? [this._fill] : [];
        }
        _onGeometryChanged() {
            this._rectGeometry = new RectGeometry(this._tag.geometry.getRect2d(this._transform));
            if (this._fill != null) {
                this._updateFillGeometry();
            }
            if (this._outline != null) {
                this._updateOulineGeometry();
            }
        }
        _onTagChanged() {
            let glObjectsChanged = false;
            if (this._fill != null) {
                this._updateFillMaterial(this._fill.material);
            }
            if (this._outline == null) {
                if (this._tag.lineWidth >= 1) {
                    this._outline = this._createOutline();
                    glObjectsChanged = true;
                }
            }
            else {
                this._updateOutlineMaterial();
            }
            return glObjectsChanged;
        }
        _getPoints3d() {
            return this._rectGeometry.getPoints3d(this._transform);
        }
        _getTriangles() {
            return this._rectGeometry.getTriangles3d(this._transform);
        }
        _updateFillMaterial(material) {
            material.color = new Color(this._tag.fillColor);
            material.opacity = this._tag.fillOpacity;
            material.needsUpdate = true;
        }
        _updateLineBasicMaterial(material) {
            material.color = new Color(this._tag.lineColor);
            material.linewidth = Math.max(this._tag.lineWidth, 1);
            material.visible = this._tag.lineWidth >= 1 && this._tag.lineOpacity > 0;
            material.opacity = this._tag.lineOpacity;
            material.transparent = this._tag.lineOpacity < 1;
            material.needsUpdate = true;
        }
        _updateOutlineMaterial() {
            let material = this._outline.material;
            this._updateLineBasicMaterial(material);
        }
    }

    /**
     * @class Tag
     * @abstract
     * @classdesc Abstract class representing the basic functionality of for a tag.
     */
    class Tag extends EventEmitter {
        /**
         * Create a tag.
         *
         * @constructor
         * @param {string} id
         * @param {Geometry} geometry
         */
        constructor(id, geometry) {
            super();
            this._id = id;
            this._geometry = geometry;
            this._notifyChanged$ = new Subject();
            this._notifyChanged$
                .subscribe((t) => {
                const type = "tag";
                const event = {
                    target: this,
                    type,
                };
                this.fire(type, event);
            });
            this._geometry.changed$
                .subscribe((g) => {
                const type = "geometry";
                const event = {
                    target: this,
                    type,
                };
                this.fire(type, event);
            });
        }
        /**
         * Get id property.
         * @returns {string}
         */
        get id() {
            return this._id;
        }
        /**
         * Get geometry property.
         * @returns {Geometry} The geometry of the tag.
         */
        get geometry() {
            return this._geometry;
        }
        /**
         * Get changed observable.
         * @returns {Observable<Tag>}
         * @ignore
         */
        get changed$() {
            return this._notifyChanged$;
        }
        /**
         * Get geometry changed observable.
         * @returns {Observable<Tag>}
         * @ignore
         */
        get geometryChanged$() {
            return this._geometry.changed$.pipe(map(() => {
                return this;
            }), share());
        }
        fire(type, event) {
            super.fire(type, event);
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
    }

    /**
     * @class ExtremePointTag
     *
     * @classdesc Tag holding properties for visualizing a extreme points
     * and their outline.
     *
     * @example
     * ```js
     * var geometry = new PointsGeometry([[0.3, 0.3], [0.5, 0.4]]);
     * var tag = new ExtremePointTag(
     *     "id-1",
     *     geometry
     *     { editable: true, lineColor: 0xff0000 });
     *
     * tagComponent.add([tag]);
     * ```
     */
    class ExtremePointTag extends Tag {
        /**
         * Create an extreme point tag.
         *
         * @override
         * @constructor
         * @param {string} id - Unique identifier of the tag.
         * @param {PointsGeometry} geometry - Geometry defining points of tag.
         * @param {ExtremePointTagOptions} options - Options defining the visual appearance and
         * behavior of the extreme point tag.
         */
        constructor(id, geometry, options) {
            super(id, geometry);
            options = !!options ? options : {};
            this._editable = options.editable == null ? false : options.editable;
            this._fillColor = options.fillColor == null ? 0xFFFFFF : options.fillColor;
            this._fillOpacity = options.fillOpacity == null ? 0.0 : options.fillOpacity;
            this._indicateVertices = options.indicateVertices == null ? true : options.indicateVertices;
            this._lineColor = options.lineColor == null ? 0xFFFFFF : options.lineColor;
            this._lineOpacity = options.lineOpacity == null ? 1 : options.lineOpacity;
            this._lineWidth = options.lineWidth == null ? 1 : options.lineWidth;
        }
        /**
         * Get editable property.
         * @returns {boolean} Value indicating if tag is editable.
         */
        get editable() {
            return this._editable;
        }
        /**
         * Set editable property.
         * @param {boolean}
         *
         * @fires changed
         */
        set editable(value) {
            this._editable = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get fill color property.
         * @returns {number}
         */
        get fillColor() {
            return this._fillColor;
        }
        /**
         * Set fill color property.
         * @param {number}
         *
         * @fires changed
         */
        set fillColor(value) {
            this._fillColor = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get fill opacity property.
         * @returns {number}
         */
        get fillOpacity() {
            return this._fillOpacity;
        }
        /**
         * Set fill opacity property.
         * @param {number}
         *
         * @fires changed
         */
        set fillOpacity(value) {
            this._fillOpacity = value;
            this._notifyChanged$.next(this);
        }
        /** @inheritdoc */
        get geometry() {
            return this._geometry;
        }
        /**
         * Get indicate vertices property.
         * @returns {boolean} Value indicating if vertices should be indicated
         * when tag is editable.
         */
        get indicateVertices() {
            return this._indicateVertices;
        }
        /**
         * Set indicate vertices property.
         * @param {boolean}
         *
         * @fires changed
         */
        set indicateVertices(value) {
            this._indicateVertices = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get line color property.
         * @returns {number}
         */
        get lineColor() {
            return this._lineColor;
        }
        /**
         * Set line color property.
         * @param {number}
         *
         * @fires changed
         */
        set lineColor(value) {
            this._lineColor = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get line opacity property.
         * @returns {number}
         */
        get lineOpacity() {
            return this._lineOpacity;
        }
        /**
         * Set line opacity property.
         * @param {number}
         *
         * @fires changed
         */
        set lineOpacity(value) {
            this._lineOpacity = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get line width property.
         * @returns {number}
         */
        get lineWidth() {
            return this._lineWidth;
        }
        /**
         * Set line width property.
         * @param {number}
         *
         * @fires changed
         */
        set lineWidth(value) {
            this._lineWidth = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Set options for tag.
         *
         * @description Sets all the option properties provided and keeps
         * the rest of the values as is.
         *
         * @param {ExtremePointTagOptions} options - Extreme point tag options
         *
         * @fires changed
         */
        setOptions(options) {
            this._editable = options.editable == null ? this._editable : options.editable;
            this._indicateVertices = options.indicateVertices == null ? this._indicateVertices : options.indicateVertices;
            this._lineColor = options.lineColor == null ? this._lineColor : options.lineColor;
            this._lineWidth = options.lineWidth == null ? this._lineWidth : options.lineWidth;
            this._fillColor = options.fillColor == null ? this._fillColor : options.fillColor;
            this._fillOpacity = options.fillOpacity == null ? this._fillOpacity : options.fillOpacity;
            this._notifyChanged$.next(this);
        }
    }

    /**
     * Enumeration for tag domains.
     * @enum {number}
     * @readonly
     * @description Defines where lines between two vertices are treated
     * as straight.
     *
     * Only applicable for polygons. For rectangles lines between
     * vertices are always treated as straight in the distorted 2D
     * projection and bended in the undistorted 3D space.
     */
    exports.TagDomain = void 0;
    (function (TagDomain) {
        /**
         * Treats lines between two vertices as straight in the
         * distorted 2D projection, i.e. on the image. If the image
         * is distorted this will result in bended lines when rendered
         * in the undistorted 3D space.
         */
        TagDomain[TagDomain["TwoDimensional"] = 0] = "TwoDimensional";
        /**
         * Treats lines as straight in the undistorted 3D space. If the
         * image is distorted this will result in bended lines when rendered
         * on the distorted 2D projection of the image.
         */
        TagDomain[TagDomain["ThreeDimensional"] = 1] = "ThreeDimensional";
    })(exports.TagDomain || (exports.TagDomain = {}));

    /**
     * @class OutlineRenderTag
     * @classdesc Tag visualizing the properties of an OutlineTag.
     */
    class OutlineRenderTag extends OutlineRenderTagBase {
        constructor(tag, transform) {
            super(tag, transform);
            this._fill = !isSpherical(transform.cameraType) ?
                this._createFill() :
                tag.domain === exports.TagDomain.TwoDimensional &&
                    tag.geometry instanceof PolygonGeometry ?
                    this._createFill() :
                    null;
            this._holes = this._tag.lineWidth >= 1 ?
                this._createHoles() :
                [];
            this._outline = this._tag.lineWidth >= 1 ?
                this._createOutline() :
                null;
        }
        dispose() {
            super.dispose();
            this._disposeFill();
            this._disposeHoles();
            this._disposeOutline();
        }
        getDOMObjects(atlas, camera, size) {
            const vNodes = [];
            const isRect = this._tag.geometry instanceof RectGeometry;
            const isPerspective = !isSpherical(this._transform.cameraType);
            const container = {
                offsetHeight: size.height, offsetWidth: size.width,
            };
            if (this._tag.icon != null && (isRect || isPerspective)) {
                const [iconBasicX, iconBasicY] = this._tag.geometry instanceof RectGeometry ?
                    this._tag.geometry.getVertex2d(this._tag.iconIndex) :
                    this._tag.geometry.getPoleOfInaccessibility2d();
                const iconCanvas = this._viewportCoords.basicToCanvasSafe(iconBasicX, iconBasicY, container, this._transform, camera);
                if (iconCanvas != null) {
                    const interact = () => {
                        this._interact$.next({ offsetX: 0, offsetY: 0, operation: TagOperation.None, tag: this._tag });
                    };
                    if (atlas.loaded) {
                        const sprite = atlas.getDOMSprite(this._tag.icon, this._tag.iconFloat);
                        const iconCanvasX = Math.round(iconCanvas[0]);
                        const iconCanvasY = Math.round(iconCanvas[1]);
                        const transform = `translate(${iconCanvasX}px,${iconCanvasY}px)`;
                        const click = (e) => {
                            e.stopPropagation();
                            this._tag.click$.next(this._tag);
                        };
                        const properties = {
                            onclick: click,
                            onpointerdown: interact,
                            style: { transform: transform },
                        };
                        vNodes.push(virtualDom.h("div.mapillary-tag-symbol", properties, [sprite]));
                    }
                }
            }
            else if (this._tag.text != null && (isRect || isPerspective)) {
                const [textBasicX, textBasicY] = this._tag.geometry instanceof RectGeometry ?
                    this._tag.geometry.getVertex2d(3) :
                    this._tag.geometry.getPoleOfInaccessibility2d();
                const textCanvas = this._viewportCoords.basicToCanvasSafe(textBasicX, textBasicY, container, this._transform, camera);
                if (textCanvas != null) {
                    const textCanvasX = Math.round(textCanvas[0]);
                    const textCanvasY = Math.round(textCanvas[1]);
                    const transform = this._tag.geometry instanceof RectGeometry ?
                        `translate(${textCanvasX}px,${textCanvasY}px)` :
                        `translate(-50%, -50%) translate(${textCanvasX}px,${textCanvasY}px)`;
                    const interact = () => {
                        this._interact$.next({ offsetX: 0, offsetY: 0, operation: TagOperation.None, tag: this._tag });
                    };
                    const properties = {
                        onpointerdown: interact,
                        style: {
                            color: this._colorToCss(this._tag.textColor),
                            transform: transform,
                        },
                        textContent: this._tag.text,
                    };
                    vNodes.push(virtualDom.h("span.mapillary-tag-symbol", properties, []));
                }
            }
            if (!this._tag.editable) {
                return vNodes;
            }
            const lineColor = this._colorToCss(this._tag.lineColor);
            if (this._tag.geometry instanceof RectGeometry) {
                const [centroidBasicX, centroidBasicY] = this._tag.geometry.getCentroid2d();
                const centroidCanvas = this._viewportCoords.basicToCanvasSafe(centroidBasicX, centroidBasicY, container, this._transform, camera);
                if (centroidCanvas != null) {
                    const interact = this._interact(TagOperation.Centroid, "move");
                    const centroidCanvasX = Math.round(centroidCanvas[0]);
                    const centroidCanvasY = Math.round(centroidCanvas[1]);
                    const transform = `translate(-50%, -50%) translate(${centroidCanvasX}px,${centroidCanvasY}px)`;
                    const properties = {
                        onpointerdown: interact,
                        style: { background: lineColor, transform: transform },
                    };
                    vNodes.push(virtualDom.h("div.mapillary-tag-mover", properties, []));
                }
            }
            const vertices2d = this._tag.geometry.getVertices2d();
            for (let i = 0; i < vertices2d.length - 1; i++) {
                if (isRect &&
                    ((this._tag.icon != null && i === this._tag.iconIndex) ||
                        (this._tag.icon == null && this._tag.text != null && i === 3))) {
                    continue;
                }
                const [vertexBasicX, vertexBasicY] = vertices2d[i];
                const vertexCanvas = this._viewportCoords.basicToCanvasSafe(vertexBasicX, vertexBasicY, container, this._transform, camera);
                if (vertexCanvas == null) {
                    continue;
                }
                const cursor = isRect ?
                    i % 2 === 0 ? "nesw-resize" : "nwse-resize" :
                    "crosshair";
                const interact = this._interact(TagOperation.Vertex, cursor, i);
                const vertexCanvasX = Math.round(vertexCanvas[0]);
                const vertexCanvasY = Math.round(vertexCanvas[1]);
                const transform = `translate(-50%, -50%) translate(${vertexCanvasX}px,${vertexCanvasY}px)`;
                const properties = {
                    onpointerdown: interact,
                    style: { background: lineColor, transform: transform, cursor: cursor },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-resizer", properties, []));
                if (!this._tag.indicateVertices) {
                    continue;
                }
                const pointProperties = {
                    style: { background: lineColor, transform: transform },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-vertex", pointProperties, []));
            }
            return vNodes;
        }
        getGLObjects() {
            const glObjects = [];
            if (this._fill != null) {
                glObjects.push(this._fill);
            }
            for (const hole of this._holes) {
                glObjects.push(hole);
            }
            if (this._outline != null) {
                glObjects.push(this._outline);
            }
            return glObjects;
        }
        getRetrievableObjects() {
            return this._fill != null ? [this._fill] : [];
        }
        _onGeometryChanged() {
            if (this._fill != null) {
                this._updateFillGeometry();
            }
            if (this._holes.length > 0) {
                this._updateHoleGeometries();
            }
            if (this._outline != null) {
                this._updateOulineGeometry();
            }
        }
        _onTagChanged() {
            let glObjectsChanged = false;
            if (this._fill != null) {
                this._updateFillMaterial(this._fill.material);
            }
            if (this._outline == null) {
                if (this._tag.lineWidth >= 1) {
                    this._holes = this._createHoles();
                    this._outline = this._createOutline();
                    glObjectsChanged = true;
                }
            }
            else {
                this._updateHoleMaterials();
                this._updateOutlineMaterial();
            }
            return glObjectsChanged;
        }
        _getPoints3d() {
            return this._in3dDomain() ?
                this._tag.geometry.getVertices3d(this._transform) :
                this._tag.geometry.getPoints3d(this._transform);
        }
        _getTriangles() {
            return this._in3dDomain() ?
                this._tag.geometry.get3dDomainTriangles3d(this._transform) :
                this._tag.geometry.getTriangles3d(this._transform);
        }
        _updateFillMaterial(material) {
            material.color = new Color(this._tag.fillColor);
            material.opacity = this._tag.fillOpacity;
            material.needsUpdate = true;
        }
        _updateLineBasicMaterial(material) {
            material.color = new Color(this._tag.lineColor);
            material.linewidth = Math.max(this._tag.lineWidth, 1);
            material.visible = this._tag.lineWidth >= 1 && this._tag.lineOpacity > 0;
            material.opacity = this._tag.lineOpacity;
            material.transparent = this._tag.lineOpacity < 1;
            material.needsUpdate = true;
        }
        _createHoles() {
            let holes = [];
            if (this._tag.geometry instanceof PolygonGeometry) {
                let holes3d = this._getHoles3d();
                for (let holePoints3d of holes3d) {
                    let hole = this._createLine(holePoints3d);
                    holes.push(hole);
                }
            }
            return holes;
        }
        _disposeHoles() {
            for (let hole of this._holes) {
                hole.geometry.dispose();
                hole.material.dispose();
            }
            this._holes = [];
        }
        _getHoles3d() {
            const polygonGeometry = this._tag.geometry;
            return this._in3dDomain() ?
                polygonGeometry.getHoleVertices3d(this._transform) :
                polygonGeometry.getHolePoints3d(this._transform);
        }
        _in3dDomain() {
            return this._tag.geometry instanceof PolygonGeometry && this._tag.domain === exports.TagDomain.ThreeDimensional;
        }
        _updateHoleGeometries() {
            let holes3d = this._getHoles3d();
            if (holes3d.length !== this._holes.length) {
                throw new Error("Changing the number of holes is not supported.");
            }
            for (let i = 0; i < this._holes.length; i++) {
                let holePoints3d = holes3d[i];
                let hole = this._holes[i];
                this._updateLine(hole, holePoints3d);
            }
        }
        _updateHoleMaterials() {
            for (const hole of this._holes) {
                this._updateLineBasicMaterial(hole.material);
            }
        }
        _updateOutlineMaterial() {
            this._updateLineBasicMaterial(this._outline.material);
        }
    }

    /**
     * Enumeration for alignments
     * @enum {number}
     * @readonly
     */
    exports.Alignment = void 0;
    (function (Alignment) {
        /**
         * Align to bottom
         */
        Alignment[Alignment["Bottom"] = 0] = "Bottom";
        /**
         * Align to bottom left
         */
        Alignment[Alignment["BottomLeft"] = 1] = "BottomLeft";
        /**
         * Align to bottom right
         */
        Alignment[Alignment["BottomRight"] = 2] = "BottomRight";
        /**
         * Align to center
         */
        Alignment[Alignment["Center"] = 3] = "Center";
        /**
         * Align to left
         */
        Alignment[Alignment["Left"] = 4] = "Left";
        /**
         * Align to right
         */
        Alignment[Alignment["Right"] = 5] = "Right";
        /**
         * Align to top
         */
        Alignment[Alignment["Top"] = 6] = "Top";
        /**
         * Align to top left
         */
        Alignment[Alignment["TopLeft"] = 7] = "TopLeft";
        /**
         * Align to top right
         */
        Alignment[Alignment["TopRight"] = 8] = "TopRight";
    })(exports.Alignment || (exports.Alignment = {}));

    /**
     * @class OutlineTag
     *
     * @classdesc Tag holding properties for visualizing a geometry outline.
     *
     * @example
     * ```js
     * var geometry = new RectGeometry([0.3, 0.3, 0.5, 0.4]);
     * var tag = new OutlineTag(
     *     "id-1",
     *     geometry
     *     { editable: true, lineColor: 0xff0000 });
     *
     * tagComponent.add([tag]);
     * ```
     */
    class OutlineTag extends Tag {
        /**
         * Create an outline tag.
         *
         * @override
         * @constructor
         * @param {string} id - Unique identifier of the tag.
         * @param {VertexGeometry} geometry - Geometry defining vertices of tag.
         * @param {OutlineTagOptions} options - Options defining the visual appearance and
         * behavior of the outline tag.
         */
        constructor(id, geometry, options) {
            super(id, geometry);
            options = !!options ? options : {};
            const domain = options.domain != null && geometry instanceof PolygonGeometry ?
                options.domain : exports.TagDomain.TwoDimensional;
            const twoDimensionalPolygon = this._twoDimensionalPolygon(domain, geometry);
            this._domain = domain;
            this._editable = options.editable == null || twoDimensionalPolygon ? false : options.editable;
            this._fillColor = options.fillColor == null ? 0xFFFFFF : options.fillColor;
            this._fillOpacity = options.fillOpacity == null ? 0.0 : options.fillOpacity;
            this._icon = options.icon === undefined ? null : options.icon;
            this._iconFloat = options.iconFloat == null ? exports.Alignment.Center : options.iconFloat;
            this._iconIndex = options.iconIndex == null ? 3 : options.iconIndex;
            this._indicateVertices = options.indicateVertices == null ? true : options.indicateVertices;
            this._lineColor = options.lineColor == null ? 0xFFFFFF : options.lineColor;
            this._lineOpacity = options.lineOpacity == null ? 1 : options.lineOpacity;
            this._lineWidth = options.lineWidth == null ? 1 : options.lineWidth;
            this._text = options.text === undefined ? null : options.text;
            this._textColor = options.textColor == null ? 0xFFFFFF : options.textColor;
            this._click$ = new Subject();
            this._click$
                .subscribe(() => {
                const type = "click";
                const event = {
                    target: this,
                    type,
                };
                this.fire(type, event);
            });
        }
        /**
         * Click observable.
         *
         * @description An observable emitting the tag when the icon of the
         * tag has been clicked.
         *
         * @returns {Observable<Tag>}
         */
        get click$() {
            return this._click$;
        }
        /**
         * Get domain property.
         *
         * @description Readonly property that can only be set in constructor.
         *
         * @returns Value indicating the domain of the tag.
         */
        get domain() {
            return this._domain;
        }
        /**
         * Get editable property.
         * @returns {boolean} Value indicating if tag is editable.
         */
        get editable() {
            return this._editable;
        }
        /**
         * Set editable property.
         * @param {boolean}
         *
         * @fires changed
         */
        set editable(value) {
            if (this._twoDimensionalPolygon(this._domain, this._geometry)) {
                return;
            }
            this._editable = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get fill color property.
         * @returns {number}
         */
        get fillColor() {
            return this._fillColor;
        }
        /**
         * Set fill color property.
         * @param {number}
         *
         * @fires changed
         */
        set fillColor(value) {
            this._fillColor = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get fill opacity property.
         * @returns {number}
         */
        get fillOpacity() {
            return this._fillOpacity;
        }
        /**
         * Set fill opacity property.
         * @param {number}
         *
         * @fires changed
         */
        set fillOpacity(value) {
            this._fillOpacity = value;
            this._notifyChanged$.next(this);
        }
        /** @inheritdoc */
        get geometry() {
            return this._geometry;
        }
        /**
         * Get icon property.
         * @returns {string}
         */
        get icon() {
            return this._icon;
        }
        /**
         * Set icon property.
         * @param {string}
         *
         * @fires changed
         */
        set icon(value) {
            this._icon = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get icon float property.
         * @returns {Alignment}
         */
        get iconFloat() {
            return this._iconFloat;
        }
        /**
         * Set icon float property.
         * @param {Alignment}
         *
         * @fires changed
         */
        set iconFloat(value) {
            this._iconFloat = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get icon index property.
         * @returns {number}
         */
        get iconIndex() {
            return this._iconIndex;
        }
        /**
         * Set icon index property.
         * @param {number}
         *
         * @fires changed
         */
        set iconIndex(value) {
            this._iconIndex = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get indicate vertices property.
         * @returns {boolean} Value indicating if vertices should be indicated
         * when tag is editable.
         */
        get indicateVertices() {
            return this._indicateVertices;
        }
        /**
         * Set indicate vertices property.
         * @param {boolean}
         *
         * @fires changed
         */
        set indicateVertices(value) {
            this._indicateVertices = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get line color property.
         * @returns {number}
         */
        get lineColor() {
            return this._lineColor;
        }
        /**
         * Set line color property.
         * @param {number}
         *
         * @fires changed
         */
        set lineColor(value) {
            this._lineColor = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get line opacity property.
         * @returns {number}
         */
        get lineOpacity() {
            return this._lineOpacity;
        }
        /**
         * Set line opacity property.
         * @param {number}
         *
         * @fires changed
         */
        set lineOpacity(value) {
            this._lineOpacity = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get line width property.
         * @returns {number}
         */
        get lineWidth() {
            return this._lineWidth;
        }
        /**
         * Set line width property.
         * @param {number}
         *
         * @fires changed
         */
        set lineWidth(value) {
            this._lineWidth = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get text property.
         * @returns {string}
         */
        get text() {
            return this._text;
        }
        /**
         * Set text property.
         * @param {string}
         *
         * @fires changed
         */
        set text(value) {
            this._text = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get text color property.
         * @returns {number}
         */
        get textColor() {
            return this._textColor;
        }
        /**
         * Set text color property.
         * @param {number}
         *
         * @fires changed
         */
        set textColor(value) {
            this._textColor = value;
            this._notifyChanged$.next(this);
        }
        fire(type, event) {
            super.fire(type, event);
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Set options for tag.
         *
         * @description Sets all the option properties provided and keeps
         * the rest of the values as is.
         *
         * @param {OutlineTagOptions} options - Outline tag options
         *
         * @fires changed
         */
        setOptions(options) {
            const twoDimensionalPolygon = this._twoDimensionalPolygon(this._domain, this._geometry);
            this._editable = twoDimensionalPolygon || options.editable == null ? this._editable : options.editable;
            this._icon = options.icon === undefined ? this._icon : options.icon;
            this._iconFloat = options.iconFloat == null ? this._iconFloat : options.iconFloat;
            this._iconIndex = options.iconIndex == null ? this._iconIndex : options.iconIndex;
            this._indicateVertices = options.indicateVertices == null ? this._indicateVertices : options.indicateVertices;
            this._lineColor = options.lineColor == null ? this._lineColor : options.lineColor;
            this._lineWidth = options.lineWidth == null ? this._lineWidth : options.lineWidth;
            this._fillColor = options.fillColor == null ? this._fillColor : options.fillColor;
            this._fillOpacity = options.fillOpacity == null ? this._fillOpacity : options.fillOpacity;
            this._text = options.text === undefined ? this._text : options.text;
            this._textColor = options.textColor == null ? this._textColor : options.textColor;
            this._notifyChanged$.next(this);
        }
        _twoDimensionalPolygon(domain, geometry) {
            return domain !== exports.TagDomain.ThreeDimensional && geometry instanceof PolygonGeometry;
        }
    }

    /**
     * @class SpotRenderTag
     * @classdesc Tag visualizing the properties of a SpotTag.
     */
    class SpotRenderTag extends RenderTag {
        dispose() { }
        getDOMObjects(atlas, camera, size) {
            const tag = this._tag;
            const container = {
                offsetHeight: size.height, offsetWidth: size.width,
            };
            const vNodes = [];
            const [centroidBasicX, centroidBasicY] = tag.geometry.getCentroid2d();
            const centroidCanvas = this._viewportCoords.basicToCanvasSafe(centroidBasicX, centroidBasicY, container, this._transform, camera);
            if (centroidCanvas != null) {
                const interactNone = (e) => {
                    this._interact$.next({ offsetX: 0, offsetY: 0, operation: TagOperation.None, tag: tag });
                };
                const canvasX = Math.round(centroidCanvas[0]);
                const canvasY = Math.round(centroidCanvas[1]);
                if (tag.icon != null) {
                    if (atlas.loaded) {
                        const sprite = atlas.getDOMSprite(tag.icon, exports.Alignment.Bottom);
                        const iconTransform = `translate(${canvasX}px,${canvasY + 8}px)`;
                        const properties = {
                            onpointerdown: interactNone,
                            style: {
                                pointerEvents: "all",
                                transform: iconTransform,
                            },
                        };
                        vNodes.push(virtualDom.h("div", properties, [sprite]));
                    }
                }
                else if (tag.text != null) {
                    const textTransform = `translate(-50%,0%) translate(${canvasX}px,${canvasY + 8}px)`;
                    const properties = {
                        onpointerdown: interactNone,
                        style: {
                            color: this._colorToCss(tag.textColor),
                            transform: textTransform,
                        },
                        textContent: tag.text,
                    };
                    vNodes.push(virtualDom.h("span.mapillary-tag-symbol", properties, []));
                }
                const interact = this._interact(TagOperation.Centroid, tag, "move");
                const background = this._colorToCss(tag.color);
                const transform = `translate(-50%,-50%) translate(${canvasX}px,${canvasY}px)`;
                if (tag.editable) {
                    let interactorProperties = {
                        onpointerdown: interact,
                        style: {
                            background: background,
                            transform: transform,
                        },
                    };
                    vNodes.push(virtualDom.h("div.mapillary-tag-spot-interactor", interactorProperties, []));
                }
                const pointProperties = {
                    style: {
                        background: background,
                        transform: transform,
                    },
                };
                vNodes.push(virtualDom.h("div.mapillary-tag-vertex", pointProperties, []));
            }
            return vNodes;
        }
        getGLObjects() { return []; }
        getRetrievableObjects() { return []; }
        _colorToCss(color) {
            return "#" + ("000000" + color.toString(16)).substr(-6);
        }
        _interact(operation, tag, cursor, vertexIndex) {
            return (e) => {
                const offsetX = e.offsetX - e.target.offsetWidth / 2;
                const offsetY = e.offsetY - e.target.offsetHeight / 2;
                this._interact$.next({
                    cursor: cursor,
                    offsetX: offsetX,
                    offsetY: offsetY,
                    operation: operation,
                    tag: tag,
                    vertexIndex: vertexIndex,
                });
            };
        }
    }

    /**
     * @class SpotTag
     *
     * @classdesc Tag holding properties for visualizing the centroid of a geometry.
     *
     * @example
     * ```js
     * var geometry = new PointGeometry([0.3, 0.3]);
     * var tag = new SpotTag(
     *     "id-1",
     *     geometry
     *     { editable: true, color: 0xff0000 });
     *
     * tagComponent.add([tag]);
     * ```
     */
    class SpotTag extends Tag {
        /**
         * Create a spot tag.
         *
         * @override
         * @constructor
         * @param {string} id
         * @param {Geometry} geometry
         * @param {IOutlineTagOptions} options - Options defining the visual appearance and
         * behavior of the spot tag.
         */
        constructor(id, geometry, options) {
            super(id, geometry);
            options = !!options ? options : {};
            this._color = options.color == null ? 0xFFFFFF : options.color;
            this._editable = options.editable == null ? false : options.editable;
            this._icon = options.icon === undefined ? null : options.icon;
            this._text = options.text === undefined ? null : options.text;
            this._textColor = options.textColor == null ? 0xFFFFFF : options.textColor;
        }
        /**
         * Get color property.
         * @returns {number} The color of the spot as a hexagonal number;
         */
        get color() {
            return this._color;
        }
        /**
         * Set color property.
         * @param {number}
         *
         * @fires changed
         */
        set color(value) {
            this._color = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get editable property.
         * @returns {boolean} Value indicating if tag is editable.
         */
        get editable() {
            return this._editable;
        }
        /**
         * Set editable property.
         * @param {boolean}
         *
         * @fires changed
         */
        set editable(value) {
            this._editable = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get icon property.
         * @returns {string}
         */
        get icon() {
            return this._icon;
        }
        /**
         * Set icon property.
         * @param {string}
         *
         * @fires changed
         */
        set icon(value) {
            this._icon = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get text property.
         * @returns {string}
         */
        get text() {
            return this._text;
        }
        /**
         * Set text property.
         * @param {string}
         *
         * @fires changed
         */
        set text(value) {
            this._text = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Get text color property.
         * @returns {number}
         */
        get textColor() {
            return this._textColor;
        }
        /**
         * Set text color property.
         * @param {number}
         *
         * @fires changed
         */
        set textColor(value) {
            this._textColor = value;
            this._notifyChanged$.next(this);
        }
        /**
         * Set options for tag.
         *
         * @description Sets all the option properties provided and keps
         * the rest of the values as is.
         *
         * @param {SpotTagOptions} options - Spot tag options
         *
         * @fires changed
         */
        setOptions(options) {
            this._color = options.color == null ? this._color : options.color;
            this._editable = options.editable == null ? this._editable : options.editable;
            this._icon = options.icon === undefined ? this._icon : options.icon;
            this._text = options.text === undefined ? this._text : options.text;
            this._textColor = options.textColor == null ? this._textColor : options.textColor;
            this._notifyChanged$.next(this);
        }
    }

    class TagSet {
        constructor() {
            this._active = false;
            this._hash = {};
            this._hashDeactivated = {};
            this._notifyChanged$ = new Subject();
        }
        get active() {
            return this._active;
        }
        get changed$() {
            return this._notifyChanged$;
        }
        activate(transform) {
            if (this._active) {
                return;
            }
            for (const id in this._hashDeactivated) {
                if (!this._hashDeactivated.hasOwnProperty(id)) {
                    continue;
                }
                const tag = this._hashDeactivated[id];
                this._add(tag, transform);
            }
            this._hashDeactivated = {};
            this._active = true;
            this._notifyChanged$.next(this);
        }
        deactivate() {
            if (!this._active) {
                return;
            }
            for (const id in this._hash) {
                if (!this._hash.hasOwnProperty(id)) {
                    continue;
                }
                this._hashDeactivated[id] = this._hash[id].tag;
            }
            this._hash = {};
            this._active = false;
        }
        add(tags, transform) {
            this._assertActivationState(true);
            for (const tag of tags) {
                this._add(tag, transform);
            }
            this._notifyChanged$.next(this);
        }
        addDeactivated(tags) {
            this._assertActivationState(false);
            for (const tag of tags) {
                if (!(tag instanceof OutlineTag ||
                    tag instanceof SpotTag ||
                    tag instanceof ExtremePointTag)) {
                    throw new Error("Tag type not supported");
                }
                this._hashDeactivated[tag.id] = tag;
            }
        }
        get(id) {
            return this.has(id) ? this._hash[id] : undefined;
        }
        getAll() {
            const hash = this._hash;
            return Object.keys(hash)
                .map((id) => {
                return hash[id];
            });
        }
        getAllDeactivated() {
            const hashDeactivated = this._hashDeactivated;
            return Object.keys(hashDeactivated)
                .map((id) => {
                return hashDeactivated[id];
            });
        }
        getDeactivated(id) {
            return this.hasDeactivated(id) ? this._hashDeactivated[id] : undefined;
        }
        has(id) {
            return id in this._hash;
        }
        hasDeactivated(id) {
            return id in this._hashDeactivated;
        }
        remove(ids) {
            this._assertActivationState(true);
            const hash = this._hash;
            for (const id of ids) {
                if (!(id in hash)) {
                    continue;
                }
                delete hash[id];
            }
            this._notifyChanged$.next(this);
        }
        removeAll() {
            this._assertActivationState(true);
            this._hash = {};
            this._notifyChanged$.next(this);
        }
        removeAllDeactivated() {
            this._assertActivationState(false);
            this._hashDeactivated = {};
        }
        removeDeactivated(ids) {
            this._assertActivationState(false);
            const hashDeactivated = this._hashDeactivated;
            for (const id of ids) {
                if (!(id in hashDeactivated)) {
                    continue;
                }
                delete hashDeactivated[id];
            }
        }
        _add(tag, transform) {
            if (tag instanceof OutlineTag) {
                this._hash[tag.id] = new OutlineRenderTag(tag, transform);
            }
            else if (tag instanceof SpotTag) {
                this._hash[tag.id] = new SpotRenderTag(tag, transform);
            }
            else if (tag instanceof ExtremePointTag) {
                this._hash[tag.id] = new ExtremePointRenderTag(tag, transform);
            }
            else {
                throw new Error("Tag type not supported");
            }
        }
        _assertActivationState(should) {
            if (should !== this._active) {
                throw new Error("Tag set not in correct state for operation.");
            }
        }
    }

    /**
     * @class PointGeometry
     *
     * @classdesc Represents a point geometry in the 2D basic image coordinate system.
     *
     * @example
     * ```js
     * var basicPoint = [0.5, 0.7];
     * var pointGeometry = new PointGeometry(basicPoint);
     * ```
     */
    class PointGeometry extends Geometry {
        /**
         * Create a point geometry.
         *
         * @constructor
         * @param {Array<number>} point - An array representing the basic coordinates of
         * the point.
         *
         * @throws {GeometryTagError} Point coordinates must be valid basic coordinates.
         */
        constructor(point) {
            super();
            let x = point[0];
            let y = point[1];
            if (x < 0 || x > 1 || y < 0 || y > 1) {
                throw new GeometryTagError("Basic coordinates must be on the interval [0, 1].");
            }
            this._point = point.slice();
        }
        /**
         * Get point property.
         * @returns {Array<number>} Array representing the basic coordinates of the point.
         */
        get point() {
            return this._point;
        }
        /**
         * Get the 2D basic coordinates for the centroid of the point, i.e. the 2D
         * basic coordinates of the point itself.
         *
         * @returns {Array<number>} 2D basic coordinates representing the centroid.
         * @ignore
         */
        getCentroid2d() {
            return this._point.slice();
        }
        /**
         * Get the 3D world coordinates for the centroid of the point, i.e. the 3D
         * world coordinates of the point itself.
         *
         * @param {Transform} transform - The transform of the image related to the point.
         * @returns {Array<number>} 3D world coordinates representing the centroid.
         * @ignore
         */
        getCentroid3d(transform) {
            return transform.unprojectBasic(this._point, 200);
        }
        /**
         * Set the centroid of the point, i.e. the point coordinates.
         *
         * @param {Array<number>} value - The new value of the centroid.
         * @param {Transform} transform - The transform of the image related to the point.
         * @ignore
         */
        setCentroid2d(value, transform) {
            let changed = [
                Math.max(0, Math.min(1, value[0])),
                Math.max(0, Math.min(1, value[1])),
            ];
            this._point[0] = changed[0];
            this._point[1] = changed[1];
            this._notifyChanged$.next(this);
        }
    }

    class TagHandlerBase extends HandlerBase {
        constructor(component, container, navigator, viewportCoords) {
            super(component, container, navigator);
            this._name = `${this._component.name}-${this._getNameExtension()}`;
            this._viewportCoords = viewportCoords;
        }
        _getConfiguration(enable) {
            return {};
        }
        _mouseEventToBasic(event, element, camera, transform, offsetX, offsetY) {
            offsetX = offsetX != null ? offsetX : 0;
            offsetY = offsetY != null ? offsetY : 0;
            const [canvasX, canvasY] = this._viewportCoords.canvasPosition(event, element);
            const basic = this._viewportCoords.canvasToBasic(canvasX - offsetX, canvasY - offsetY, element, transform, camera.perspective);
            return basic;
        }
    }

    class CreateHandlerBase extends TagHandlerBase {
        constructor(component, container, navigator, viewportCoords, tagCreator) {
            super(component, container, navigator, viewportCoords);
            this._tagCreator = tagCreator;
            this._geometryCreated$ = new Subject();
        }
        get geometryCreated$() {
            return this._geometryCreated$;
        }
        _enable() {
            this._enableCreate();
            this._container.container.classList.add("component-tag-create");
        }
        _disable() {
            this._container.container.classList.remove("component-tag-create");
            this._disableCreate();
        }
        _validateBasic(basic) {
            const x = basic[0];
            const y = basic[1];
            return 0 <= x && x <= 1 && 0 <= y && y <= 1;
        }
        _mouseEventToBasic$(mouseEvent$) {
            return mouseEvent$.pipe(withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$), map(([event, camera, transform]) => {
                return this._mouseEventToBasic(event, this._container.container, camera, transform);
            }));
        }
    }

    class CreatePointHandler extends CreateHandlerBase {
        _enableCreate() {
            this._container.mouseService.deferPixels(this._name, 4);
            this._geometryCreatedSubscription = this._mouseEventToBasic$(this._container.mouseService.proximateClick$).pipe(filter(this._validateBasic), map((basic) => {
                return new PointGeometry(basic);
            }))
                .subscribe(this._geometryCreated$);
        }
        _disableCreate() {
            this._container.mouseService.undeferPixels(this._name);
            this._geometryCreatedSubscription.unsubscribe();
        }
        _getNameExtension() {
            return "create-point";
        }
    }

    class CreateVertexHandler extends CreateHandlerBase {
        _enableCreate() {
            this._container.mouseService.deferPixels(this._name, 4);
            const transformChanged$ = this._navigator.stateService.currentTransform$.pipe(map(() => { }), publishReplay(1), refCount());
            this._deleteSubscription = transformChanged$.pipe(skip(1))
                .subscribe(this._tagCreator.delete$);
            const basicClick$ = this._mouseEventToBasic$(this._container.mouseService.proximateClick$).pipe(share());
            this._createSubscription = transformChanged$.pipe(switchMap(() => {
                return basicClick$.pipe(filter(this._validateBasic), take(1));
            }))
                .subscribe(this._create$);
            this._setVertexSubscription = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return !!tag ?
                    combineLatest(of(tag), merge(this._container.mouseService.mouseMove$, this._container.mouseService.domMouseMove$), this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$) :
                    empty();
            }))
                .subscribe(([tag, event, camera, transform]) => {
                const basicPoint = this._mouseEventToBasic(event, this._container.container, camera, transform);
                this._setVertex2d(tag, basicPoint, transform);
            });
            this._addPointSubscription = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return !!tag ?
                    combineLatest(of(tag), basicClick$) :
                    empty();
            }))
                .subscribe(([tag, basicPoint]) => {
                this._addPoint(tag, basicPoint);
            });
            this._geometryCreateSubscription = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return !!tag ?
                    tag.created$.pipe(map((t) => {
                        return t.geometry;
                    })) :
                    empty();
            }))
                .subscribe(this._geometryCreated$);
        }
        _disableCreate() {
            this._container.mouseService.undeferPixels(this._name);
            this._tagCreator.delete$.next(null);
            this._addPointSubscription.unsubscribe();
            this._createSubscription.unsubscribe();
            this._deleteSubscription.unsubscribe();
            this._geometryCreateSubscription.unsubscribe();
            this._setVertexSubscription.unsubscribe();
        }
    }

    class CreatePointsHandler extends CreateVertexHandler {
        get _create$() {
            return this._tagCreator.createPoints$;
        }
        _addPoint(tag, basicPoint) {
            tag.geometry.addPoint2d(basicPoint);
        }
        _getNameExtension() {
            return "create-points";
        }
        _setVertex2d(tag, basicPoint, transform) {
            tag.geometry.setPoint2d((tag.geometry).points.length - 1, basicPoint, transform);
        }
    }

    class CreatePolygonHandler extends CreateVertexHandler {
        get _create$() {
            return this._tagCreator.createPolygon$;
        }
        _addPoint(tag, basicPoint) {
            tag.addPoint(basicPoint);
        }
        _getNameExtension() {
            return "create-polygon";
        }
        _setVertex2d(tag, basicPoint, transform) {
            tag.geometry.setVertex2d(tag.geometry.polygon.length - 2, basicPoint, transform);
        }
    }

    class CreateRectHandler extends CreateVertexHandler {
        get _create$() {
            return this._tagCreator.createRect$;
        }
        _addPoint(tag, basicPoint) {
            const rectGeometry = tag.geometry;
            if (!rectGeometry.validate(basicPoint)) {
                basicPoint = rectGeometry.getNonAdjustedVertex2d(3);
            }
            tag.addPoint(basicPoint);
        }
        _enable() {
            super._enable();
            this._initializeAnchorIndexingSubscription = this._tagCreator.tag$.pipe(filter((tag) => {
                return !!tag;
            }))
                .subscribe((tag) => {
                tag.geometry.initializeAnchorIndexing();
            });
        }
        _disable() {
            super._disable();
            this._initializeAnchorIndexingSubscription.unsubscribe();
        }
        _getNameExtension() {
            return "create-rect";
        }
        _setVertex2d(tag, basicPoint, transform) {
            tag.geometry.setOppositeVertex2d(basicPoint, transform);
        }
    }

    class CreateRectDragHandler extends CreateHandlerBase {
        _enableCreate() {
            this._container.mouseService.claimMouse(this._name, 2);
            this._deleteSubscription = this._navigator.stateService.currentTransform$.pipe(map((transform) => { return null; }), skip(1))
                .subscribe(this._tagCreator.delete$);
            this._createSubscription = this._mouseEventToBasic$(this._container.mouseService.filtered$(this._name, this._container.mouseService.mouseDragStart$)).pipe(filter(this._validateBasic))
                .subscribe(this._tagCreator.createRect$);
            this._initializeAnchorIndexingSubscription = this._tagCreator.tag$.pipe(filter((tag) => {
                return !!tag;
            }))
                .subscribe((tag) => {
                tag.geometry.initializeAnchorIndexing();
            });
            const basicMouse$ = combineLatest(merge(this._container.mouseService.filtered$(this._name, this._container.mouseService.mouseMove$), this._container.mouseService.filtered$(this._name, this._container.mouseService.domMouseMove$)), this._container.renderService.renderCamera$).pipe(withLatestFrom(this._navigator.stateService.currentTransform$), map(([[event, camera], transform]) => {
                return this._mouseEventToBasic(event, this._container.container, camera, transform);
            }));
            this._setVertexSubscription = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return !!tag ?
                    combineLatest(of(tag), basicMouse$, this._navigator.stateService.currentTransform$) :
                    empty();
            }))
                .subscribe(([tag, basicPoint, transform]) => {
                tag.geometry.setOppositeVertex2d(basicPoint, transform);
            });
            const basicMouseDragEnd$ = this._container.mouseService.mouseDragEnd$.pipe(withLatestFrom(this._mouseEventToBasic$(this._container.mouseService.filtered$(this._name, this._container.mouseService.mouseDrag$)).pipe(filter(this._validateBasic)), (event, basicPoint) => {
                return basicPoint;
            }), share());
            this._addPointSubscription = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return !!tag ?
                    combineLatest(of(tag), basicMouseDragEnd$) :
                    empty();
            }))
                .subscribe(([tag, basicPoint]) => {
                const rectGeometry = tag.geometry;
                if (!rectGeometry.validate(basicPoint)) {
                    basicPoint = rectGeometry.getNonAdjustedVertex2d(3);
                }
                tag.addPoint(basicPoint);
            });
            this._geometryCreatedSubscription = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return !!tag ?
                    tag.created$.pipe(map((t) => {
                        return t.geometry;
                    })) :
                    empty();
            }))
                .subscribe(this._geometryCreated$);
        }
        _disableCreate() {
            this._container.mouseService.unclaimMouse(this._name);
            this._tagCreator.delete$.next(null);
            this._addPointSubscription.unsubscribe();
            this._createSubscription.unsubscribe();
            this._deleteSubscription.unsubscribe();
            this._geometryCreatedSubscription.unsubscribe();
            this._initializeAnchorIndexingSubscription.unsubscribe();
            this._setVertexSubscription.unsubscribe();
        }
        _getNameExtension() {
            return "create-rect-drag";
        }
    }

    class EditVertexHandler extends TagHandlerBase {
        constructor(component, container, navigator, viewportCoords, tagSet) {
            super(component, container, navigator, viewportCoords);
            this._tagSet = tagSet;
        }
        _enable() {
            const interaction$ = this._tagSet.changed$.pipe(map((tagSet) => {
                return tagSet.getAll();
            }), switchMap((tags) => {
                return from(tags).pipe(mergeMap((tag) => {
                    return tag.interact$;
                }));
            }), switchMap((interaction) => {
                return concat(of(interaction), this._container.mouseService.documentMouseUp$.pipe(map(() => {
                    return { offsetX: 0, offsetY: 0, operation: TagOperation.None, tag: null };
                }), first()));
            }), share());
            merge(this._container.mouseService.mouseMove$, this._container.mouseService.domMouseMove$).pipe(share());
            this._claimMouseSubscription = interaction$.pipe(switchMap((interaction) => {
                return !!interaction.tag ? this._container.mouseService.domMouseDragStart$ : empty();
            }))
                .subscribe(() => {
                this._container.mouseService.claimMouse(this._name, 3);
            });
            this._cursorSubscription = interaction$.pipe(map((interaction) => {
                return interaction.cursor;
            }), distinctUntilChanged())
                .subscribe((cursor) => {
                const interactionCursors = ["crosshair", "move", "nesw-resize", "nwse-resize"];
                for (const interactionCursor of interactionCursors) {
                    this._container.container.classList.remove(`component-tag-edit-${interactionCursor}`);
                }
                if (!!cursor) {
                    this._container.container.classList.add(`component-tag-edit-${cursor}`);
                }
            });
            this._unclaimMouseSubscription = this._container.mouseService
                .filtered$(this._name, this._container.mouseService.domMouseDragEnd$)
                .subscribe((e) => {
                this._container.mouseService.unclaimMouse(this._name);
            });
            this._preventDefaultSubscription = interaction$.pipe(switchMap((interaction) => {
                return !!interaction.tag ?
                    this._container.mouseService.documentMouseMove$ :
                    empty();
            }))
                .subscribe((event) => {
                event.preventDefault(); // prevent selection of content outside the viewer
            });
            this._updateGeometrySubscription = interaction$.pipe(switchMap((interaction) => {
                if (interaction.operation === TagOperation.None || !interaction.tag) {
                    return empty();
                }
                const mouseDrag$ = this._container.mouseService
                    .filtered$(this._name, this._container.mouseService.domMouseDrag$).pipe(filter((event) => {
                    return this._viewportCoords.insideElement(event, this._container.container);
                }));
                return combineLatest(mouseDrag$, this._container.renderService.renderCamera$).pipe(withLatestFrom(of(interaction), this._navigator.stateService.currentTransform$, ([event, render], i, transform) => {
                    return [event, render, i, transform];
                }));
            }))
                .subscribe(([mouseEvent, renderCamera, interaction, transform]) => {
                const basic = this._mouseEventToBasic(mouseEvent, this._container.container, renderCamera, transform, interaction.offsetX, interaction.offsetY);
                const geometry = interaction.tag.geometry;
                if (interaction.operation === TagOperation.Centroid) {
                    geometry.setCentroid2d(basic, transform);
                }
                else if (interaction.operation === TagOperation.Vertex) {
                    geometry.setVertex2d(interaction.vertexIndex, basic, transform);
                }
            });
        }
        _disable() {
            this._claimMouseSubscription.unsubscribe();
            this._cursorSubscription.unsubscribe();
            this._preventDefaultSubscription.unsubscribe();
            this._unclaimMouseSubscription.unsubscribe();
            this._updateGeometrySubscription.unsubscribe();
        }
        _getNameExtension() {
            return "edit-vertex";
        }
    }

    /**
     * @class TagComponent
     *
     * @classdesc Component for showing and editing tags with different
     * geometries composed from 2D basic image coordinates (see the
     * {@link Viewer} class documentation for more information about coordinate
     * systems).
     *
     * The `add` method is used for adding new tags or replacing
     * tags already in the set. Tags are removed by id.
     *
     * If a tag already in the set has the same
     * id as one of the tags added, the old tag will be removed and
     * the added tag will take its place.
     *
     * The tag component mode can be set to either be non interactive or
     * to be in creating mode of a certain geometry type.
     *
     * The tag properties can be updated at any time and the change will
     * be visibile immediately.
     *
     * Tags are only relevant to a single image because they are based on
     * 2D basic image coordinates. Tags related to a certain image should
     * be removed when the viewer is moved to another image.
     *
     * To retrive and use the tag component
     *
     * @example
     * ```js
     * var viewer = new Viewer({ component: { tag: true } }, ...);
     *
     * var tagComponent = viewer.getComponent("tag");
     * ```
     */
    class TagComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._tagDomRenderer = new TagDOMRenderer();
            this._tagScene = new TagScene();
            this._tagSet = new TagSet();
            this._tagCreator = new TagCreator(this, navigator);
            this._viewportCoords = new ViewportCoords();
            this._createHandlers = {
                "CreatePoint": new CreatePointHandler(this, container, navigator, this._viewportCoords, this._tagCreator),
                "CreatePoints": new CreatePointsHandler(this, container, navigator, this._viewportCoords, this._tagCreator),
                "CreatePolygon": new CreatePolygonHandler(this, container, navigator, this._viewportCoords, this._tagCreator),
                "CreateRect": new CreateRectHandler(this, container, navigator, this._viewportCoords, this._tagCreator),
                "CreateRectDrag": new CreateRectDragHandler(this, container, navigator, this._viewportCoords, this._tagCreator),
                "Default": undefined,
            };
            this._editVertexHandler =
                new EditVertexHandler(this, container, navigator, this._viewportCoords, this._tagSet);
            this._renderTags$ = this._tagSet.changed$.pipe(map((tagSet) => {
                const tags = tagSet.getAll();
                // ensure that tags are always rendered in the same order
                // to avoid hover tracking problems on first resize.
                tags.sort((t1, t2) => {
                    const id1 = t1.tag.id;
                    const id2 = t2.tag.id;
                    if (id1 < id2) {
                        return -1;
                    }
                    if (id1 > id2) {
                        return 1;
                    }
                    return 0;
                });
                return tags;
            }), share());
            this._tagChanged$ = this._renderTags$.pipe(switchMap((tags) => {
                return from(tags).pipe(mergeMap((tag) => {
                    return merge(tag.tag.changed$, tag.tag.geometryChanged$);
                }));
            }), share());
            this._renderTagGLChanged$ = this._renderTags$.pipe(switchMap((tags) => {
                return from(tags).pipe(mergeMap((tag) => {
                    return tag.glObjectsChanged$;
                }));
            }), share());
            this._createGeometryChanged$ = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return tag != null ?
                    tag.geometryChanged$ :
                    empty();
            }), share());
            this._createGLObjectsChanged$ = this._tagCreator.tag$.pipe(switchMap((tag) => {
                return tag != null ?
                    tag.glObjectsChanged$ :
                    empty();
            }), share());
            this._creatingConfiguration$ = this._configuration$.pipe(distinctUntilChanged((c1, c2) => {
                return c1.mode === c2.mode;
            }, (configuration) => {
                return {
                    createColor: configuration.createColor,
                    mode: configuration.mode,
                };
            }), publishReplay(1), refCount());
            this._creatingConfiguration$
                .subscribe((configuration) => {
                const type = "tagmode";
                const event = {
                    mode: configuration.mode,
                    target: this,
                    type,
                };
                this.fire(type, event);
            });
        }
        /**
         * Add tags to the tag set or replace tags in the tag set.
         *
         * @description If a tag already in the set has the same
         * id as one of the tags added, the old tag will be removed
         * the added tag will take its place.
         *
         * @param {Array<Tag>} tags - Tags to add.
         *
         * @example
         * ```js
         * tagComponent.add([tag1, tag2]);
         * ```
         */
        add(tags) {
            if (this._activated) {
                this._navigator.stateService.currentTransform$.pipe(first())
                    .subscribe((transform) => {
                    this._tagSet.add(tags, transform);
                    const renderTags = tags
                        .map((tag) => {
                        return this._tagSet.get(tag.id);
                    });
                    this._tagScene.add(renderTags);
                });
            }
            else {
                this._tagSet.addDeactivated(tags);
            }
        }
        /**
         * Calculate the smallest rectangle containing all the points
         * in the points geometry.
         *
         * @description The result may be different depending on if the
         * current image is an spherical or not. If the
         * current image is an spherical the rectangle may
         * wrap the horizontal border of the image.
         *
         * @returns {Promise<Array<number>>} Promise to the rectangle
         * on the format specified for the {@link RectGeometry} in basic
         * coordinates.
         */
        calculateRect(geometry) {
            return new Promise((resolve, reject) => {
                this._navigator.stateService.currentTransform$.pipe(first(), map((transform) => {
                    return geometry.getRect2d(transform);
                }))
                    .subscribe((rect) => {
                    resolve(rect);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Force the creation of a geometry programatically using its
         * current vertices.
         *
         * @description The method only has an effect when the tag
         * mode is either of the following modes:
         *
         * {@link TagMode.CreatePoints}
         * {@link TagMode.CreatePolygon}
         * {@link TagMode.CreateRect}
         * {@link TagMode.CreateRectDrag}
         *
         * In the case of points or polygon creation, only the created
         * vertices are used, i.e. the mouse position is disregarded.
         *
         * In the case of rectangle creation the position of the mouse
         * at the time of the method call is used as one of the vertices
         * defining the rectangle.
         *
         * @fires geometrycreate
         *
         * @example
         * ```js
         * tagComponent.on("geometrycreate", function(geometry) {
         *     console.log(geometry);
         * });
         *
         * tagComponent.create();
         * ```
         */
        create() {
            this._tagCreator.replayedTag$.pipe(first(), filter((tag) => {
                return !!tag;
            }))
                .subscribe((tag) => {
                tag.create();
            });
        }
        /**
         * Change the current tag mode.
         *
         * @description Change the tag mode to one of the create modes for creating new geometries.
         *
         * @param {TagMode} mode - New tag mode.
         *
         * @fires tagmode
         *
         * @example
         * ```js
         * tagComponent.changeMode(TagMode.CreateRect);
         * ```
         */
        changeMode(mode) {
            this.configure({ mode: mode });
        }
        fire(type, event) {
            super.fire(type, event);
        }
        /**
         * Returns the tag in the tag set with the specified id, or
         * undefined if the id matches no tag.
         *
         * @param {string} tagId - Id of the tag.
         *
         * @example
         * ```js
         * var tag = tagComponent.get("tagId");
         * ```
         */
        get(tagId) {
            if (this._activated) {
                const renderTag = this._tagSet.get(tagId);
                return renderTag !== undefined ? renderTag.tag : undefined;
            }
            else {
                return this._tagSet.getDeactivated(tagId);
            }
        }
        /**
         * Returns an array of all tags.
         *
         * @example
         * ```js
         * var tags = tagComponent.getAll();
         * ```
         */
        getAll() {
            if (this.activated) {
                return this._tagSet
                    .getAll()
                    .map((renderTag) => {
                    return renderTag.tag;
                });
            }
            else {
                return this._tagSet.getAllDeactivated();
            }
        }
        /**
         * Returns an array of tag ids for tags that contain the specified point.
         *
         * @description The pixel point must lie inside the polygon or rectangle
         * of an added tag for the tag id to be returned. Tag ids for
         * tags that do not have a fill will also be returned if the point is inside
         * the geometry of the tag. Tags with point geometries can not be retrieved.
         *
         * No tag ids will be returned for polygons rendered in cropped spherical or
         * rectangles rendered in spherical.
         *
         * Notice that the pixelPoint argument requires x, y coordinates from pixel space.
         *
         * With this function, you can use the coordinates provided by mouse
         * events to get information out of the tag component.
         *
         * If no tag at exist the pixel point, an empty array will be returned.
         *
         * @param {Array<number>} pixelPoint - Pixel coordinates on the viewer element.
         * @returns {Promise<Array<string>>} Promise to the ids of the tags that
         * contain the specified pixel point.
         *
         * @example
         * ```js
         * tagComponent.getTagIdsAt([100, 100])
         *     .then((tagIds) => { console.log(tagIds); });
         * ```
         */
        getTagIdsAt(pixelPoint) {
            return new Promise((resolve, reject) => {
                this._container.renderService.renderCamera$.pipe(first(), map((render) => {
                    const viewport = this._viewportCoords
                        .canvasToViewport(pixelPoint[0], pixelPoint[1], this._container.container);
                    const ids = this._tagScene.intersectObjects(viewport, render.perspective);
                    return ids;
                }))
                    .subscribe((ids) => {
                    resolve(ids);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Check if a tag exist in the tag set.
         *
         * @param {string} tagId - Id of the tag.
         *
         * @example
         * ```js
         * var tagExists = tagComponent.has("tagId");
         * ```
         */
        has(tagId) {
            return this._activated ? this._tagSet.has(tagId) : this._tagSet.hasDeactivated(tagId);
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Remove tags with the specified ids from the tag set.
         *
         * @param {Array<string>} tagIds - Ids for tags to remove.
         *
         * @example
         * ```js
         * tagComponent.remove(["id-1", "id-2"]);
         * ```
         */
        remove(tagIds) {
            if (this._activated) {
                this._tagSet.remove(tagIds);
                this._tagScene.remove(tagIds);
            }
            else {
                this._tagSet.removeDeactivated(tagIds);
            }
        }
        /**
         * Remove all tags from the tag set.
         *
         * @example
         * ```js
         * tagComponent.removeAll();
         * ```
         */
        removeAll() {
            if (this._activated) {
                this._tagSet.removeAll();
                this._tagScene.removeAll();
            }
            else {
                this._tagSet.removeAllDeactivated();
            }
        }
        _activate() {
            this._editVertexHandler.enable();
            const handlerGeometryCreated$ = from(Object.keys(this._createHandlers)).pipe(map((key) => {
                return this._createHandlers[key];
            }), filter((handler) => {
                return !!handler;
            }), mergeMap((handler) => {
                return handler.geometryCreated$;
            }), share());
            const subs = this._subscriptions;
            subs.push(handlerGeometryCreated$
                .subscribe((geometry) => {
                const type = "geometrycreate";
                const event = {
                    geometry,
                    target: this,
                    type,
                };
                this.fire(type, event);
            }));
            subs.push(this._tagCreator.tag$.pipe(skipWhile((tag) => {
                return tag == null;
            }), distinctUntilChanged())
                .subscribe((tag) => {
                const type = tag != null ?
                    "tagcreatestart" :
                    "tagcreateend";
                const event = {
                    target: this,
                    type,
                };
                this.fire(type, event);
            }));
            subs.push(handlerGeometryCreated$
                .subscribe(() => {
                this.changeMode(exports.TagMode.Default);
            }));
            subs.push(this._creatingConfiguration$
                .subscribe((configuration) => {
                this._disableCreateHandlers();
                const mode = exports.TagMode[configuration.mode];
                const handler = this._createHandlers[mode];
                if (!!handler) {
                    handler.enable();
                }
            }));
            subs.push(this._renderTags$
                .subscribe(() => {
                const type = "tags";
                const event = {
                    target: this,
                    type,
                };
                this.fire(type, event);
            }));
            subs.push(this._tagCreator.tag$.pipe(switchMap((tag) => {
                return tag != null ?
                    tag.aborted$.pipe(map(() => { return null; })) :
                    empty();
            }))
                .subscribe(() => { this.changeMode(exports.TagMode.Default); }));
            subs.push(this._tagCreator.tag$
                .subscribe((tag) => {
                if (this._tagScene.hasCreateTag()) {
                    this._tagScene.removeCreateTag();
                }
                if (tag != null) {
                    this._tagScene.addCreateTag(tag);
                }
            }));
            subs.push(this._createGLObjectsChanged$
                .subscribe((tag) => {
                this._tagScene.updateCreateTagObjects(tag);
            }));
            subs.push(this._renderTagGLChanged$
                .subscribe((tag) => {
                this._tagScene.updateObjects(tag);
            }));
            subs.push(this._tagChanged$
                .subscribe(() => {
                this._tagScene.update();
            }));
            subs.push(combineLatest(this._renderTags$.pipe(startWith([]), tap(() => {
                this._container.domRenderer.render$.next({
                    name: this._name,
                    vNode: this._tagDomRenderer.clear(),
                });
            })), this._container.renderService.renderCamera$, this._container.spriteService.spriteAtlas$, this._container.renderService.size$, this._tagChanged$.pipe(startWith(null)), merge(this._tagCreator.tag$, this._createGeometryChanged$).pipe(startWith(null))).pipe(map(([renderTags, rc, atlas, size, , ct]) => {
                return {
                    name: this._name,
                    vNode: this._tagDomRenderer.render(renderTags, ct, atlas, rc.perspective, size),
                };
            }))
                .subscribe(this._container.domRenderer.render$));
            subs.push(this._navigator.stateService.currentState$.pipe(map((frame) => {
                const tagScene = this._tagScene;
                return {
                    name: this._name,
                    renderer: {
                        frameId: frame.id,
                        needsRender: tagScene.needsRender,
                        render: tagScene.render.bind(tagScene),
                        pass: RenderPass.Opaque,
                    },
                };
            }))
                .subscribe(this._container.glRenderer.render$));
            this._navigator.stateService.currentTransform$.pipe(first())
                .subscribe((transform) => {
                this._tagSet.activate(transform);
                this._tagScene.add(this._tagSet.getAll());
            });
        }
        _deactivate() {
            this._editVertexHandler.disable();
            this._disableCreateHandlers();
            this._tagScene.clear();
            this._tagSet.deactivate();
            this._tagCreator.delete$.next(null);
            this._subscriptions.unsubscribe();
            this._container.container.classList.remove("component-tag-create");
        }
        _getDefaultConfiguration() {
            return {
                createColor: 0xFFFFFF,
                indicatePointsCompleter: true,
                mode: exports.TagMode.Default,
            };
        }
        _disableCreateHandlers() {
            const createHandlers = this._createHandlers;
            for (const key in createHandlers) {
                if (!createHandlers.hasOwnProperty(key)) {
                    continue;
                }
                const handler = createHandlers[key];
                if (!!handler) {
                    handler.disable();
                }
            }
        }
    }
    /** @inheritdoc */
    TagComponent.componentName = "tag";

    /**
     * @class ZoomComponent
     *
     * @classdesc Component rendering UI elements used for zooming.
     *
     * @example
     * ```js
     * var viewer = new Viewer({ ... });
     *
     * var zoomComponent = viewer.getComponent("zoom");
     * zoomComponent.configure({ size: ComponentSize.Small });
     * ```
     */
    class ZoomComponent extends Component {
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._viewportCoords = new ViewportCoords();
            this._zoomDelta$ = new Subject();
        }
        _activate() {
            const subs = this._subscriptions;
            subs.push(combineLatest(this._navigator.stateService.currentState$, this._navigator.stateService.state$, this._configuration$, this._container.renderService.size$).pipe(map(([frame, state, configuration, size]) => {
                const zoom = frame.state.zoom;
                const zoomInIcon = virtualDom.h("div.mapillary-zoom-in-icon", []);
                const zoomInButton = zoom >= 3 || state === State.Waiting ?
                    virtualDom.h("div.mapillary-zoom-in-button-inactive", [zoomInIcon]) :
                    virtualDom.h("div.mapillary-zoom-in-button", { onclick: () => { this._zoomDelta$.next(1); } }, [zoomInIcon]);
                const zoomOutIcon = virtualDom.h("div.mapillary-zoom-out-icon", []);
                const zoomOutButton = zoom <= 0 || state === State.Waiting ?
                    virtualDom.h("div.mapillary-zoom-out-button-inactive", [zoomOutIcon]) :
                    virtualDom.h("div.mapillary-zoom-out-button", { onclick: () => { this._zoomDelta$.next(-1); } }, [zoomOutIcon]);
                const compact = configuration.size === exports.ComponentSize.Small ||
                    configuration.size === exports.ComponentSize.Automatic && size.width < 640 ?
                    ".mapillary-zoom-compact" : "";
                return {
                    name: this._name,
                    vNode: virtualDom.h("div.mapillary-zoom-container" + compact, { oncontextmenu: (event) => { event.preventDefault(); } }, [zoomInButton, zoomOutButton]),
                };
            }))
                .subscribe(this._container.domRenderer.render$));
            subs.push(this._zoomDelta$.pipe(withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$))
                .subscribe(([zoomDelta, render, transform]) => {
                const unprojected = this._viewportCoords.unprojectFromViewport(0, 0, render.perspective);
                const reference = transform.projectBasic(unprojected.toArray());
                this._navigator.stateService.zoomIn(zoomDelta, reference);
            }));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return { size: exports.ComponentSize.Automatic };
        }
    }
    ZoomComponent.componentName = "zoom";

    class ImageFallbackComponent extends Component {
        constructor(name, container, navigator, dom) {
            super(name, container, navigator);
            this._canvasId = `${container.id}-${this._name}`;
            this._dom = !!dom ? dom : new DOM();
        }
        _activate() {
            const canvasSize$ = this._container.domRenderer.element$.pipe(map(() => {
                return this._dom.document.getElementById(this._canvasId);
            }), filter((canvas) => {
                return !!canvas;
            }), map((canvas) => {
                const adaptableDomRenderer = canvas.parentElement;
                const width = adaptableDomRenderer.offsetWidth;
                const height = adaptableDomRenderer.offsetHeight;
                return [canvas, { height: height, width: width }];
            }), distinctUntilChanged((s1, s2) => {
                return s1.height === s2.height && s1.width === s2.width;
            }, ([, size]) => {
                return size;
            }));
            this._subscriptions.push(combineLatest(canvasSize$, this._navigator.stateService.currentImage$)
                .subscribe(([[canvas, size], image]) => {
                canvas.width = size.width;
                canvas.height = size.height;
                canvas
                    .getContext("2d")
                    .drawImage(image.image, 0, 0, size.width, size.height);
            }));
            this._container.domRenderer.renderAdaptive$.next({ name: this._name, vNode: virtualDom.h(`canvas#${this._canvasId}`, []) });
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return {};
        }
    }
    ImageFallbackComponent.componentName = "imagefallback";

    /**
     * @class NavigationFallbackComponent
     *
     * @classdesc Fallback navigation component for environments without WebGL support.
     *
     * Replaces the functionality in the Direction and Sequence components.
     */
    class NavigationFallbackComponent extends Component {
        /** @ignore */
        constructor(name, container, navigator) {
            super(name, container, navigator);
            this._seqNames = {};
            this._seqNames[exports.NavigationDirection[exports.NavigationDirection.Prev]] = "-prev";
            this._seqNames[exports.NavigationDirection[exports.NavigationDirection.Next]] = "-next";
            this._spaTopNames = {};
            this._spaTopNames[exports.NavigationDirection[exports.NavigationDirection.TurnLeft]] = "-turn-left";
            this._spaTopNames[exports.NavigationDirection[exports.NavigationDirection.StepLeft]] = "-left";
            this._spaTopNames[exports.NavigationDirection[exports.NavigationDirection.StepForward]] = "-forward";
            this._spaTopNames[exports.NavigationDirection[exports.NavigationDirection.StepRight]] = "-right";
            this._spaTopNames[exports.NavigationDirection[exports.NavigationDirection.TurnRight]] = "-turn-right";
            this._spaBottomNames = {};
            this._spaBottomNames[exports.NavigationDirection[exports.NavigationDirection.TurnU]] = "-turn-around";
            this._spaBottomNames[exports.NavigationDirection[exports.NavigationDirection.StepBackward]] = "-backward";
        }
        _activate() {
            this._subscriptions.push(combineLatest(this._navigator.stateService.currentImage$, this._configuration$).pipe(switchMap(([image, configuration]) => {
                const sequenceEdges$ = configuration.sequence ?
                    image.sequenceEdges$.pipe(map((status) => {
                        return status.edges
                            .map((edge) => {
                            return edge.data.direction;
                        });
                    })) :
                    of([]);
                const spatialEdges$ = !isSpherical(image.cameraType) &&
                    configuration.spatial ?
                    image.spatialEdges$.pipe(map((status) => {
                        return status.edges
                            .map((edge) => {
                            return edge.data.direction;
                        });
                    })) :
                    of([]);
                return combineLatest(sequenceEdges$, spatialEdges$).pipe(map(([seq, spa]) => {
                    return seq.concat(spa);
                }));
            }), map((edgeDirections) => {
                const seqs = this._createArrowRow(this._seqNames, edgeDirections);
                const spaTops = this._createArrowRow(this._spaTopNames, edgeDirections);
                const spaBottoms = this._createArrowRow(this._spaBottomNames, edgeDirections);
                const seqContainer = virtualDom.h(`div.mapillary-navigation-sequence`, seqs);
                const spaTopContainer = virtualDom.h(`div.NavigationSpatialTop`, spaTops);
                const spaBottomContainer = virtualDom.h(`div.mapillary-navigation-spatial-bottom`, spaBottoms);
                const spaContainer = virtualDom.h(`div.mapillary-navigation-spatial`, [spaTopContainer, spaBottomContainer]);
                return { name: this._name, vNode: virtualDom.h(`div.NavigationContainer`, [seqContainer, spaContainer]) };
            }))
                .subscribe(this._container.domRenderer.render$));
        }
        _deactivate() {
            this._subscriptions.unsubscribe();
        }
        _getDefaultConfiguration() {
            return { sequence: true, spatial: true };
        }
        _createArrowRow(arrowNames, edgeDirections) {
            const arrows = [];
            for (const arrowName in arrowNames) {
                if (!(arrowNames.hasOwnProperty(arrowName))) {
                    continue;
                }
                const direction = exports.NavigationDirection[arrowName];
                if (edgeDirections.indexOf(direction) !== -1) {
                    arrows.push(this._createVNode(direction, arrowNames[arrowName], "visible"));
                }
                else {
                    arrows.push(this._createVNode(direction, arrowNames[arrowName], "hidden"));
                }
            }
            return arrows;
        }
        _createVNode(direction, name, visibility) {
            return virtualDom.h(`span.mapillary-navigation-button.mapillary-navigation${name}`, {
                onclick: () => {
                    this._navigator.moveDir$(direction)
                        .subscribe(undefined, (error) => {
                        if (!(error instanceof CancelMapillaryError)) {
                            console.error(error);
                        }
                    });
                },
                style: {
                    visibility: visibility,
                },
            }, []);
        }
    }
    NavigationFallbackComponent.componentName = "navigationfallback";

    /*! pako 2.0.3 https://github.com/nodeca/pako @license (MIT AND Zlib) */
    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    /* eslint-disable space-unary-ops */

    /* Public constants ==========================================================*/
    /* ===========================================================================*/


    //const Z_FILTERED          = 1;
    //const Z_HUFFMAN_ONLY      = 2;
    //const Z_RLE               = 3;
    const Z_FIXED               = 4;
    //const Z_DEFAULT_STRATEGY  = 0;

    /* Possible values of the data_type field (though see inflate()) */
    const Z_BINARY              = 0;
    const Z_TEXT                = 1;
    //const Z_ASCII             = 1; // = Z_TEXT
    const Z_UNKNOWN             = 2;

    /*============================================================================*/


    function zero(buf) { let len = buf.length; while (--len >= 0) { buf[len] = 0; } }

    // From zutil.h

    const STORED_BLOCK = 0;
    const STATIC_TREES = 1;
    const DYN_TREES    = 2;
    /* The three kinds of block type */

    const MIN_MATCH    = 3;
    const MAX_MATCH    = 258;
    /* The minimum and maximum match lengths */

    // From deflate.h
    /* ===========================================================================
     * Internal compression state.
     */

    const LENGTH_CODES  = 29;
    /* number of length codes, not counting the special END_BLOCK code */

    const LITERALS      = 256;
    /* number of literal bytes 0..255 */

    const L_CODES       = LITERALS + 1 + LENGTH_CODES;
    /* number of Literal or Length codes, including the END_BLOCK code */

    const D_CODES       = 30;
    /* number of distance codes */

    const BL_CODES      = 19;
    /* number of codes used to transfer the bit lengths */

    const HEAP_SIZE     = 2 * L_CODES + 1;
    /* maximum heap size */

    const MAX_BITS      = 15;
    /* All codes must not exceed MAX_BITS bits */

    const Buf_size      = 16;
    /* size of bit buffer in bi_buf */


    /* ===========================================================================
     * Constants
     */

    const MAX_BL_BITS = 7;
    /* Bit length codes must not exceed MAX_BL_BITS bits */

    const END_BLOCK   = 256;
    /* end of block literal code */

    const REP_3_6     = 16;
    /* repeat previous bit length 3-6 times (2 bits of repeat count) */

    const REPZ_3_10   = 17;
    /* repeat a zero length 3-10 times  (3 bits of repeat count) */

    const REPZ_11_138 = 18;
    /* repeat a zero length 11-138 times  (7 bits of repeat count) */

    /* eslint-disable comma-spacing,array-bracket-spacing */
    const extra_lbits =   /* extra bits for each length code */
      new Uint8Array([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]);

    const extra_dbits =   /* extra bits for each distance code */
      new Uint8Array([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]);

    const extra_blbits =  /* extra bits for each bit length code */
      new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]);

    const bl_order =
      new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);
    /* eslint-enable comma-spacing,array-bracket-spacing */

    /* The lengths of the bit length codes are sent in order of decreasing
     * probability, to avoid transmitting the lengths for unused bit length codes.
     */

    /* ===========================================================================
     * Local data. These are initialized only once.
     */

    // We pre-fill arrays with 0 to avoid uninitialized gaps

    const DIST_CODE_LEN = 512; /* see definition of array dist_code below */

    // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1
    const static_ltree  = new Array((L_CODES + 2) * 2);
    zero(static_ltree);
    /* The static literal tree. Since the bit lengths are imposed, there is no
     * need for the L_CODES extra codes used during heap construction. However
     * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
     * below).
     */

    const static_dtree  = new Array(D_CODES * 2);
    zero(static_dtree);
    /* The static distance tree. (Actually a trivial tree since all codes use
     * 5 bits.)
     */

    const _dist_code    = new Array(DIST_CODE_LEN);
    zero(_dist_code);
    /* Distance codes. The first 256 values correspond to the distances
     * 3 .. 258, the last 256 values correspond to the top 8 bits of
     * the 15 bit distances.
     */

    const _length_code  = new Array(MAX_MATCH - MIN_MATCH + 1);
    zero(_length_code);
    /* length code for each normalized match length (0 == MIN_MATCH) */

    const base_length   = new Array(LENGTH_CODES);
    zero(base_length);
    /* First normalized length for each code (0 = MIN_MATCH) */

    const base_dist     = new Array(D_CODES);
    zero(base_dist);
    /* First normalized distance for each code (0 = distance of 1) */


    function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {

      this.static_tree  = static_tree;  /* static tree or NULL */
      this.extra_bits   = extra_bits;   /* extra bits for each code or NULL */
      this.extra_base   = extra_base;   /* base index for extra_bits */
      this.elems        = elems;        /* max number of elements in the tree */
      this.max_length   = max_length;   /* max bit length for the codes */

      // show if `static_tree` has data or dummy - needed for monomorphic objects
      this.has_stree    = static_tree && static_tree.length;
    }


    let static_l_desc;
    let static_d_desc;
    let static_bl_desc;


    function TreeDesc(dyn_tree, stat_desc) {
      this.dyn_tree = dyn_tree;     /* the dynamic tree */
      this.max_code = 0;            /* largest code with non zero frequency */
      this.stat_desc = stat_desc;   /* the corresponding static tree */
    }



    const d_code = (dist) => {

      return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
    };


    /* ===========================================================================
     * Output a short LSB first on the stream.
     * IN assertion: there is enough room in pendingBuf.
     */
    const put_short = (s, w) => {
    //    put_byte(s, (uch)((w) & 0xff));
    //    put_byte(s, (uch)((ush)(w) >> 8));
      s.pending_buf[s.pending++] = (w) & 0xff;
      s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
    };


    /* ===========================================================================
     * Send a value on a given number of bits.
     * IN assertion: length <= 16 and value fits in length bits.
     */
    const send_bits = (s, value, length) => {

      if (s.bi_valid > (Buf_size - length)) {
        s.bi_buf |= (value << s.bi_valid) & 0xffff;
        put_short(s, s.bi_buf);
        s.bi_buf = value >> (Buf_size - s.bi_valid);
        s.bi_valid += length - Buf_size;
      } else {
        s.bi_buf |= (value << s.bi_valid) & 0xffff;
        s.bi_valid += length;
      }
    };


    const send_code = (s, c, tree) => {

      send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);
    };


    /* ===========================================================================
     * Reverse the first len bits of a code, using straightforward code (a faster
     * method would use a table)
     * IN assertion: 1 <= len <= 15
     */
    const bi_reverse = (code, len) => {

      let res = 0;
      do {
        res |= code & 1;
        code >>>= 1;
        res <<= 1;
      } while (--len > 0);
      return res >>> 1;
    };


    /* ===========================================================================
     * Flush the bit buffer, keeping at most 7 bits in it.
     */
    const bi_flush = (s) => {

      if (s.bi_valid === 16) {
        put_short(s, s.bi_buf);
        s.bi_buf = 0;
        s.bi_valid = 0;

      } else if (s.bi_valid >= 8) {
        s.pending_buf[s.pending++] = s.bi_buf & 0xff;
        s.bi_buf >>= 8;
        s.bi_valid -= 8;
      }
    };


    /* ===========================================================================
     * Compute the optimal bit lengths for a tree and update the total bit length
     * for the current block.
     * IN assertion: the fields freq and dad are set, heap[heap_max] and
     *    above are the tree nodes sorted by increasing frequency.
     * OUT assertions: the field len is set to the optimal bit length, the
     *     array bl_count contains the frequencies for each bit length.
     *     The length opt_len is updated; static_len is also updated if stree is
     *     not null.
     */
    const gen_bitlen = (s, desc) =>
    //    deflate_state *s;
    //    tree_desc *desc;    /* the tree descriptor */
    {
      const tree            = desc.dyn_tree;
      const max_code        = desc.max_code;
      const stree           = desc.stat_desc.static_tree;
      const has_stree       = desc.stat_desc.has_stree;
      const extra           = desc.stat_desc.extra_bits;
      const base            = desc.stat_desc.extra_base;
      const max_length      = desc.stat_desc.max_length;
      let h;              /* heap index */
      let n, m;           /* iterate over the tree elements */
      let bits;           /* bit length */
      let xbits;          /* extra bits */
      let f;              /* frequency */
      let overflow = 0;   /* number of elements with bit length too large */

      for (bits = 0; bits <= MAX_BITS; bits++) {
        s.bl_count[bits] = 0;
      }

      /* In a first pass, compute the optimal bit lengths (which may
       * overflow in the case of the bit length tree).
       */
      tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */

      for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
        n = s.heap[h];
        bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
        if (bits > max_length) {
          bits = max_length;
          overflow++;
        }
        tree[n * 2 + 1]/*.Len*/ = bits;
        /* We overwrite tree[n].Dad which is no longer needed */

        if (n > max_code) { continue; } /* not a leaf node */

        s.bl_count[bits]++;
        xbits = 0;
        if (n >= base) {
          xbits = extra[n - base];
        }
        f = tree[n * 2]/*.Freq*/;
        s.opt_len += f * (bits + xbits);
        if (has_stree) {
          s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);
        }
      }
      if (overflow === 0) { return; }

      // Trace((stderr,"\nbit length overflow\n"));
      /* This happens for example on obj2 and pic of the Calgary corpus */

      /* Find the first bit length which could increase: */
      do {
        bits = max_length - 1;
        while (s.bl_count[bits] === 0) { bits--; }
        s.bl_count[bits]--;      /* move one leaf down the tree */
        s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
        s.bl_count[max_length]--;
        /* The brother of the overflow item also moves one step up,
         * but this does not affect bl_count[max_length]
         */
        overflow -= 2;
      } while (overflow > 0);

      /* Now recompute all bit lengths, scanning in increasing frequency.
       * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
       * lengths instead of fixing only the wrong ones. This idea is taken
       * from 'ar' written by Haruhiko Okumura.)
       */
      for (bits = max_length; bits !== 0; bits--) {
        n = s.bl_count[bits];
        while (n !== 0) {
          m = s.heap[--h];
          if (m > max_code) { continue; }
          if (tree[m * 2 + 1]/*.Len*/ !== bits) {
            // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
            s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
            tree[m * 2 + 1]/*.Len*/ = bits;
          }
          n--;
        }
      }
    };


    /* ===========================================================================
     * Generate the codes for a given tree and bit counts (which need not be
     * optimal).
     * IN assertion: the array bl_count contains the bit length statistics for
     * the given tree and the field len is set for all tree elements.
     * OUT assertion: the field code is set for all tree elements of non
     *     zero code length.
     */
    const gen_codes = (tree, max_code, bl_count) =>
    //    ct_data *tree;             /* the tree to decorate */
    //    int max_code;              /* largest code with non zero frequency */
    //    ushf *bl_count;            /* number of codes at each bit length */
    {
      const next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
      let code = 0;              /* running code value */
      let bits;                  /* bit index */
      let n;                     /* code index */

      /* The distribution counts are first used to generate the code values
       * without bit reversal.
       */
      for (bits = 1; bits <= MAX_BITS; bits++) {
        next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
      }
      /* Check that the bit counts in bl_count are consistent. The last code
       * must be all ones.
       */
      //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
      //        "inconsistent bit counts");
      //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));

      for (n = 0;  n <= max_code; n++) {
        let len = tree[n * 2 + 1]/*.Len*/;
        if (len === 0) { continue; }
        /* Now reverse the bits */
        tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);

        //Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
        //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
      }
    };


    /* ===========================================================================
     * Initialize the various 'constant' tables.
     */
    const tr_static_init = () => {

      let n;        /* iterates over tree elements */
      let bits;     /* bit counter */
      let length;   /* length value */
      let code;     /* code value */
      let dist;     /* distance index */
      const bl_count = new Array(MAX_BITS + 1);
      /* number of codes at each bit length for an optimal tree */

      // do check in _tr_init()
      //if (static_init_done) return;

      /* For some embedded targets, global variables are not initialized: */
    /*#ifdef NO_INIT_GLOBAL_POINTERS
      static_l_desc.static_tree = static_ltree;
      static_l_desc.extra_bits = extra_lbits;
      static_d_desc.static_tree = static_dtree;
      static_d_desc.extra_bits = extra_dbits;
      static_bl_desc.extra_bits = extra_blbits;
    #endif*/

      /* Initialize the mapping length (0..255) -> length code (0..28) */
      length = 0;
      for (code = 0; code < LENGTH_CODES - 1; code++) {
        base_length[code] = length;
        for (n = 0; n < (1 << extra_lbits[code]); n++) {
          _length_code[length++] = code;
        }
      }
      //Assert (length == 256, "tr_static_init: length != 256");
      /* Note that the length 255 (match length 258) can be represented
       * in two different ways: code 284 + 5 bits or code 285, so we
       * overwrite length_code[255] to use the best encoding:
       */
      _length_code[length - 1] = code;

      /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
      dist = 0;
      for (code = 0; code < 16; code++) {
        base_dist[code] = dist;
        for (n = 0; n < (1 << extra_dbits[code]); n++) {
          _dist_code[dist++] = code;
        }
      }
      //Assert (dist == 256, "tr_static_init: dist != 256");
      dist >>= 7; /* from now on, all distances are divided by 128 */
      for (; code < D_CODES; code++) {
        base_dist[code] = dist << 7;
        for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
          _dist_code[256 + dist++] = code;
        }
      }
      //Assert (dist == 256, "tr_static_init: 256+dist != 512");

      /* Construct the codes of the static literal tree */
      for (bits = 0; bits <= MAX_BITS; bits++) {
        bl_count[bits] = 0;
      }

      n = 0;
      while (n <= 143) {
        static_ltree[n * 2 + 1]/*.Len*/ = 8;
        n++;
        bl_count[8]++;
      }
      while (n <= 255) {
        static_ltree[n * 2 + 1]/*.Len*/ = 9;
        n++;
        bl_count[9]++;
      }
      while (n <= 279) {
        static_ltree[n * 2 + 1]/*.Len*/ = 7;
        n++;
        bl_count[7]++;
      }
      while (n <= 287) {
        static_ltree[n * 2 + 1]/*.Len*/ = 8;
        n++;
        bl_count[8]++;
      }
      /* Codes 286 and 287 do not exist, but we must include them in the
       * tree construction to get a canonical Huffman tree (longest code
       * all ones)
       */
      gen_codes(static_ltree, L_CODES + 1, bl_count);

      /* The static distance tree is trivial: */
      for (n = 0; n < D_CODES; n++) {
        static_dtree[n * 2 + 1]/*.Len*/ = 5;
        static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
      }

      // Now data ready and we can init static trees
      static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
      static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS);
      static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES, MAX_BL_BITS);

      //static_init_done = true;
    };


    /* ===========================================================================
     * Initialize a new block.
     */
    const init_block = (s) => {

      let n; /* iterates over tree elements */

      /* Initialize the trees. */
      for (n = 0; n < L_CODES;  n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
      for (n = 0; n < D_CODES;  n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
      for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }

      s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
      s.opt_len = s.static_len = 0;
      s.last_lit = s.matches = 0;
    };


    /* ===========================================================================
     * Flush the bit buffer and align the output on a byte boundary
     */
    const bi_windup = (s) =>
    {
      if (s.bi_valid > 8) {
        put_short(s, s.bi_buf);
      } else if (s.bi_valid > 0) {
        //put_byte(s, (Byte)s->bi_buf);
        s.pending_buf[s.pending++] = s.bi_buf;
      }
      s.bi_buf = 0;
      s.bi_valid = 0;
    };

    /* ===========================================================================
     * Copy a stored block, storing first the length and its
     * one's complement if requested.
     */
    const copy_block = (s, buf, len, header) =>
    //DeflateState *s;
    //charf    *buf;    /* the input data */
    //unsigned len;     /* its length */
    //int      header;  /* true if block header must be written */
    {
      bi_windup(s);        /* align on byte boundary */

      if (header) {
        put_short(s, len);
        put_short(s, ~len);
      }
    //  while (len--) {
    //    put_byte(s, *buf++);
    //  }
      s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending);
      s.pending += len;
    };

    /* ===========================================================================
     * Compares to subtrees, using the tree depth as tie breaker when
     * the subtrees have equal frequency. This minimizes the worst case length.
     */
    const smaller = (tree, n, m, depth) => {

      const _n2 = n * 2;
      const _m2 = m * 2;
      return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
             (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
    };

    /* ===========================================================================
     * Restore the heap property by moving down the tree starting at node k,
     * exchanging a node with the smallest of its two sons if necessary, stopping
     * when the heap property is re-established (each father smaller than its
     * two sons).
     */
    const pqdownheap = (s, tree, k) =>
    //    deflate_state *s;
    //    ct_data *tree;  /* the tree to restore */
    //    int k;               /* node to move down */
    {
      const v = s.heap[k];
      let j = k << 1;  /* left son of k */
      while (j <= s.heap_len) {
        /* Set j to the smallest of the two sons: */
        if (j < s.heap_len &&
          smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
          j++;
        }
        /* Exit if v is smaller than both sons */
        if (smaller(tree, v, s.heap[j], s.depth)) { break; }

        /* Exchange v with the smallest son */
        s.heap[k] = s.heap[j];
        k = j;

        /* And continue down the tree, setting j to the left son of k */
        j <<= 1;
      }
      s.heap[k] = v;
    };


    // inlined manually
    // const SMALLEST = 1;

    /* ===========================================================================
     * Send the block data compressed using the given Huffman trees
     */
    const compress_block = (s, ltree, dtree) =>
    //    deflate_state *s;
    //    const ct_data *ltree; /* literal tree */
    //    const ct_data *dtree; /* distance tree */
    {
      let dist;           /* distance of matched string */
      let lc;             /* match length or unmatched char (if dist == 0) */
      let lx = 0;         /* running index in l_buf */
      let code;           /* the code to send */
      let extra;          /* number of extra bits to send */

      if (s.last_lit !== 0) {
        do {
          dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
          lc = s.pending_buf[s.l_buf + lx];
          lx++;

          if (dist === 0) {
            send_code(s, lc, ltree); /* send a literal byte */
            //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
          } else {
            /* Here, lc is the match length - MIN_MATCH */
            code = _length_code[lc];
            send_code(s, code + LITERALS + 1, ltree); /* send the length code */
            extra = extra_lbits[code];
            if (extra !== 0) {
              lc -= base_length[code];
              send_bits(s, lc, extra);       /* send the extra length bits */
            }
            dist--; /* dist is now the match distance - 1 */
            code = d_code(dist);
            //Assert (code < D_CODES, "bad d_code");

            send_code(s, code, dtree);       /* send the distance code */
            extra = extra_dbits[code];
            if (extra !== 0) {
              dist -= base_dist[code];
              send_bits(s, dist, extra);   /* send the extra distance bits */
            }
          } /* literal or match pair ? */

          /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
          //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
          //       "pendingBuf overflow");

        } while (lx < s.last_lit);
      }

      send_code(s, END_BLOCK, ltree);
    };


    /* ===========================================================================
     * Construct one Huffman tree and assigns the code bit strings and lengths.
     * Update the total bit length for the current block.
     * IN assertion: the field freq is set for all tree elements.
     * OUT assertions: the fields len and code are set to the optimal bit length
     *     and corresponding code. The length opt_len is updated; static_len is
     *     also updated if stree is not null. The field max_code is set.
     */
    const build_tree = (s, desc) =>
    //    deflate_state *s;
    //    tree_desc *desc; /* the tree descriptor */
    {
      const tree     = desc.dyn_tree;
      const stree    = desc.stat_desc.static_tree;
      const has_stree = desc.stat_desc.has_stree;
      const elems    = desc.stat_desc.elems;
      let n, m;          /* iterate over heap elements */
      let max_code = -1; /* largest code with non zero frequency */
      let node;          /* new node being created */

      /* Construct the initial heap, with least frequent element in
       * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
       * heap[0] is not used.
       */
      s.heap_len = 0;
      s.heap_max = HEAP_SIZE;

      for (n = 0; n < elems; n++) {
        if (tree[n * 2]/*.Freq*/ !== 0) {
          s.heap[++s.heap_len] = max_code = n;
          s.depth[n] = 0;

        } else {
          tree[n * 2 + 1]/*.Len*/ = 0;
        }
      }

      /* The pkzip format requires that at least one distance code exists,
       * and that at least one bit should be sent even if there is only one
       * possible code. So to avoid special checks later on we force at least
       * two codes of non zero frequency.
       */
      while (s.heap_len < 2) {
        node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
        tree[node * 2]/*.Freq*/ = 1;
        s.depth[node] = 0;
        s.opt_len--;

        if (has_stree) {
          s.static_len -= stree[node * 2 + 1]/*.Len*/;
        }
        /* node is 0 or 1 so it does not have extra bits */
      }
      desc.max_code = max_code;

      /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
       * establish sub-heaps of increasing lengths:
       */
      for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }

      /* Construct the Huffman tree by repeatedly combining the least two
       * frequent nodes.
       */
      node = elems;              /* next internal node of the tree */
      do {
        //pqremove(s, tree, n);  /* n = node of least frequency */
        /*** pqremove ***/
        n = s.heap[1/*SMALLEST*/];
        s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];
        pqdownheap(s, tree, 1/*SMALLEST*/);
        /***/

        m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */

        s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */
        s.heap[--s.heap_max] = m;

        /* Create a new node father of n and m */
        tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
        s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
        tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;

        /* and insert the new node in the heap */
        s.heap[1/*SMALLEST*/] = node++;
        pqdownheap(s, tree, 1/*SMALLEST*/);

      } while (s.heap_len >= 2);

      s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];

      /* At this point, the fields freq and dad are set. We can now
       * generate the bit lengths.
       */
      gen_bitlen(s, desc);

      /* The field len is now set, we can generate the bit codes */
      gen_codes(tree, max_code, s.bl_count);
    };


    /* ===========================================================================
     * Scan a literal or distance tree to determine the frequencies of the codes
     * in the bit length tree.
     */
    const scan_tree = (s, tree, max_code) =>
    //    deflate_state *s;
    //    ct_data *tree;   /* the tree to be scanned */
    //    int max_code;    /* and its largest code of non zero frequency */
    {
      let n;                     /* iterates over all tree elements */
      let prevlen = -1;          /* last emitted length */
      let curlen;                /* length of current code */

      let nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */

      let count = 0;             /* repeat count of the current code */
      let max_count = 7;         /* max repeat count */
      let min_count = 4;         /* min repeat count */

      if (nextlen === 0) {
        max_count = 138;
        min_count = 3;
      }
      tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */

      for (n = 0; n <= max_code; n++) {
        curlen = nextlen;
        nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;

        if (++count < max_count && curlen === nextlen) {
          continue;

        } else if (count < min_count) {
          s.bl_tree[curlen * 2]/*.Freq*/ += count;

        } else if (curlen !== 0) {

          if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
          s.bl_tree[REP_3_6 * 2]/*.Freq*/++;

        } else if (count <= 10) {
          s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;

        } else {
          s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;
        }

        count = 0;
        prevlen = curlen;

        if (nextlen === 0) {
          max_count = 138;
          min_count = 3;

        } else if (curlen === nextlen) {
          max_count = 6;
          min_count = 3;

        } else {
          max_count = 7;
          min_count = 4;
        }
      }
    };


    /* ===========================================================================
     * Send a literal or distance tree in compressed form, using the codes in
     * bl_tree.
     */
    const send_tree = (s, tree, max_code) =>
    //    deflate_state *s;
    //    ct_data *tree; /* the tree to be scanned */
    //    int max_code;       /* and its largest code of non zero frequency */
    {
      let n;                     /* iterates over all tree elements */
      let prevlen = -1;          /* last emitted length */
      let curlen;                /* length of current code */

      let nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */

      let count = 0;             /* repeat count of the current code */
      let max_count = 7;         /* max repeat count */
      let min_count = 4;         /* min repeat count */

      /* tree[max_code+1].Len = -1; */  /* guard already set */
      if (nextlen === 0) {
        max_count = 138;
        min_count = 3;
      }

      for (n = 0; n <= max_code; n++) {
        curlen = nextlen;
        nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;

        if (++count < max_count && curlen === nextlen) {
          continue;

        } else if (count < min_count) {
          do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);

        } else if (curlen !== 0) {
          if (curlen !== prevlen) {
            send_code(s, curlen, s.bl_tree);
            count--;
          }
          //Assert(count >= 3 && count <= 6, " 3_6?");
          send_code(s, REP_3_6, s.bl_tree);
          send_bits(s, count - 3, 2);

        } else if (count <= 10) {
          send_code(s, REPZ_3_10, s.bl_tree);
          send_bits(s, count - 3, 3);

        } else {
          send_code(s, REPZ_11_138, s.bl_tree);
          send_bits(s, count - 11, 7);
        }

        count = 0;
        prevlen = curlen;
        if (nextlen === 0) {
          max_count = 138;
          min_count = 3;

        } else if (curlen === nextlen) {
          max_count = 6;
          min_count = 3;

        } else {
          max_count = 7;
          min_count = 4;
        }
      }
    };


    /* ===========================================================================
     * Construct the Huffman tree for the bit lengths and return the index in
     * bl_order of the last bit length code to send.
     */
    const build_bl_tree = (s) => {

      let max_blindex;  /* index of last bit length code of non zero freq */

      /* Determine the bit length frequencies for literal and distance trees */
      scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
      scan_tree(s, s.dyn_dtree, s.d_desc.max_code);

      /* Build the bit length tree: */
      build_tree(s, s.bl_desc);
      /* opt_len now includes the length of the tree representations, except
       * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
       */

      /* Determine the number of bit length codes to send. The pkzip format
       * requires that at least 4 bit length codes be sent. (appnote.txt says
       * 3 but the actual value used is 4.)
       */
      for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
        if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
          break;
        }
      }
      /* Update opt_len to include the bit length tree and counts */
      s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
      //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
      //        s->opt_len, s->static_len));

      return max_blindex;
    };


    /* ===========================================================================
     * Send the header for a block using dynamic Huffman trees: the counts, the
     * lengths of the bit length codes, the literal tree and the distance tree.
     * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
     */
    const send_all_trees = (s, lcodes, dcodes, blcodes) =>
    //    deflate_state *s;
    //    int lcodes, dcodes, blcodes; /* number of codes for each tree */
    {
      let rank;                    /* index in bl_order */

      //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
      //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
      //        "too many codes");
      //Tracev((stderr, "\nbl counts: "));
      send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */
      send_bits(s, dcodes - 1,   5);
      send_bits(s, blcodes - 4,  4); /* not -3 as stated in appnote.txt */
      for (rank = 0; rank < blcodes; rank++) {
        //Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
        send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);
      }
      //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));

      send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */
      //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));

      send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */
      //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
    };


    /* ===========================================================================
     * Check if the data type is TEXT or BINARY, using the following algorithm:
     * - TEXT if the two conditions below are satisfied:
     *    a) There are no non-portable control characters belonging to the
     *       "black list" (0..6, 14..25, 28..31).
     *    b) There is at least one printable character belonging to the
     *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
     * - BINARY otherwise.
     * - The following partially-portable control characters form a
     *   "gray list" that is ignored in this detection algorithm:
     *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
     * IN assertion: the fields Freq of dyn_ltree are set.
     */
    const detect_data_type = (s) => {
      /* black_mask is the bit mask of black-listed bytes
       * set bits 0..6, 14..25, and 28..31
       * 0xf3ffc07f = binary 11110011111111111100000001111111
       */
      let black_mask = 0xf3ffc07f;
      let n;

      /* Check for non-textual ("black-listed") bytes. */
      for (n = 0; n <= 31; n++, black_mask >>>= 1) {
        if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
          return Z_BINARY;
        }
      }

      /* Check for textual ("white-listed") bytes. */
      if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
          s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
        return Z_TEXT;
      }
      for (n = 32; n < LITERALS; n++) {
        if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
          return Z_TEXT;
        }
      }

      /* There are no "black-listed" or "white-listed" bytes:
       * this stream either is empty or has tolerated ("gray-listed") bytes only.
       */
      return Z_BINARY;
    };


    let static_init_done = false;

    /* ===========================================================================
     * Initialize the tree data structures for a new zlib stream.
     */
    const _tr_init = (s) =>
    {

      if (!static_init_done) {
        tr_static_init();
        static_init_done = true;
      }

      s.l_desc  = new TreeDesc(s.dyn_ltree, static_l_desc);
      s.d_desc  = new TreeDesc(s.dyn_dtree, static_d_desc);
      s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);

      s.bi_buf = 0;
      s.bi_valid = 0;

      /* Initialize the first block of the first file: */
      init_block(s);
    };


    /* ===========================================================================
     * Send a stored block
     */
    const _tr_stored_block = (s, buf, stored_len, last) =>
    //DeflateState *s;
    //charf *buf;       /* input block */
    //ulg stored_len;   /* length of input block */
    //int last;         /* one if this is the last block for a file */
    {
      send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);    /* send block type */
      copy_block(s, buf, stored_len, true); /* with header */
    };


    /* ===========================================================================
     * Send one empty static block to give enough lookahead for inflate.
     * This takes 10 bits, of which 7 may remain in the bit buffer.
     */
    const _tr_align = (s) => {
      send_bits(s, STATIC_TREES << 1, 3);
      send_code(s, END_BLOCK, static_ltree);
      bi_flush(s);
    };


    /* ===========================================================================
     * Determine the best encoding for the current block: dynamic trees, static
     * trees or store, and output the encoded block to the zip file.
     */
    const _tr_flush_block = (s, buf, stored_len, last) =>
    //DeflateState *s;
    //charf *buf;       /* input block, or NULL if too old */
    //ulg stored_len;   /* length of input block */
    //int last;         /* one if this is the last block for a file */
    {
      let opt_lenb, static_lenb;  /* opt_len and static_len in bytes */
      let max_blindex = 0;        /* index of last bit length code of non zero freq */

      /* Build the Huffman trees unless a stored block is forced */
      if (s.level > 0) {

        /* Check if the file is binary or text */
        if (s.strm.data_type === Z_UNKNOWN) {
          s.strm.data_type = detect_data_type(s);
        }

        /* Construct the literal and distance trees */
        build_tree(s, s.l_desc);
        // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
        //        s->static_len));

        build_tree(s, s.d_desc);
        // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
        //        s->static_len));
        /* At this point, opt_len and static_len are the total bit lengths of
         * the compressed block data, excluding the tree representations.
         */

        /* Build the bit length tree for the above two trees, and get the index
         * in bl_order of the last bit length code to send.
         */
        max_blindex = build_bl_tree(s);

        /* Determine the best encoding. Compute the block lengths in bytes. */
        opt_lenb = (s.opt_len + 3 + 7) >>> 3;
        static_lenb = (s.static_len + 3 + 7) >>> 3;

        // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
        //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
        //        s->last_lit));

        if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }

      } else {
        // Assert(buf != (char*)0, "lost buf");
        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
      }

      if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
        /* 4: two words for the lengths */

        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
         * Otherwise we can't have processed more than WSIZE input bytes since
         * the last block flush, because compression would have been
         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
         * transform a block into a stored block.
         */
        _tr_stored_block(s, buf, stored_len, last);

      } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {

        send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
        compress_block(s, static_ltree, static_dtree);

      } else {
        send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
        send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
        compress_block(s, s.dyn_ltree, s.dyn_dtree);
      }
      // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
      /* The above check is made mod 2^32, for files larger than 512 MB
       * and uLong implemented on 32 bits.
       */
      init_block(s);

      if (last) {
        bi_windup(s);
      }
      // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
      //       s->compressed_len-7*last));
    };

    /* ===========================================================================
     * Save the match info and tally the frequency counts. Return true if
     * the current block must be flushed.
     */
    const _tr_tally = (s, dist, lc) =>
    //    deflate_state *s;
    //    unsigned dist;  /* distance of matched string */
    //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
    {
      //let out_length, in_length, dcode;

      s.pending_buf[s.d_buf + s.last_lit * 2]     = (dist >>> 8) & 0xff;
      s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;

      s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
      s.last_lit++;

      if (dist === 0) {
        /* lc is the unmatched char */
        s.dyn_ltree[lc * 2]/*.Freq*/++;
      } else {
        s.matches++;
        /* Here, lc is the match length - MIN_MATCH */
        dist--;             /* dist = match distance - 1 */
        //Assert((ush)dist < (ush)MAX_DIST(s) &&
        //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
        //       (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");

        s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
        s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
      }

    // (!) This block is disabled in zlib defaults,
    // don't enable it for binary compatibility

    //#ifdef TRUNCATE_BLOCK
    //  /* Try to guess if it is profitable to stop the current block here */
    //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
    //    /* Compute an upper bound for the compressed length */
    //    out_length = s.last_lit*8;
    //    in_length = s.strstart - s.block_start;
    //
    //    for (dcode = 0; dcode < D_CODES; dcode++) {
    //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
    //    }
    //    out_length >>>= 3;
    //    //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
    //    //       s->last_lit, in_length, out_length,
    //    //       100L - out_length*100L/in_length));
    //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
    //      return true;
    //    }
    //  }
    //#endif

      return (s.last_lit === s.lit_bufsize - 1);
      /* We avoid equality with lit_bufsize because of wraparound at 64K
       * on 16 bit machines and because stored blocks are restricted to
       * 64K-1 bytes.
       */
    };

    var _tr_init_1  = _tr_init;
    var _tr_stored_block_1 = _tr_stored_block;
    var _tr_flush_block_1  = _tr_flush_block;
    var _tr_tally_1 = _tr_tally;
    var _tr_align_1 = _tr_align;

    var trees = {
        _tr_init: _tr_init_1,
        _tr_stored_block: _tr_stored_block_1,
        _tr_flush_block: _tr_flush_block_1,
        _tr_tally: _tr_tally_1,
        _tr_align: _tr_align_1
    };

    // Note: adler32 takes 12% for level 0 and 2% for level 6.
    // It isn't worth it to make additional optimizations as in original.
    // Small size is preferable.

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    const adler32 = (adler, buf, len, pos) => {
      let s1 = (adler & 0xffff) |0,
          s2 = ((adler >>> 16) & 0xffff) |0,
          n = 0;

      while (len !== 0) {
        // Set limit ~ twice less than 5552, to keep
        // s2 in 31-bits, because we force signed ints.
        // in other case %= will fail.
        n = len > 2000 ? 2000 : len;
        len -= n;

        do {
          s1 = (s1 + buf[pos++]) |0;
          s2 = (s2 + s1) |0;
        } while (--n);

        s1 %= 65521;
        s2 %= 65521;
      }

      return (s1 | (s2 << 16)) |0;
    };


    var adler32_1 = adler32;

    // Note: we can't get significant speed boost here.
    // So write code to minimize size - no pregenerated tables
    // and array tools dependencies.

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    // Use ordinary array, since untyped makes no boost here
    const makeTable = () => {
      let c, table = [];

      for (var n = 0; n < 256; n++) {
        c = n;
        for (var k = 0; k < 8; k++) {
          c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
        }
        table[n] = c;
      }

      return table;
    };

    // Create table on load. Just 255 signed longs. Not a problem.
    const crcTable = new Uint32Array(makeTable());


    const crc32 = (crc, buf, len, pos) => {
      const t = crcTable;
      const end = pos + len;

      crc ^= -1;

      for (let i = pos; i < end; i++) {
        crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
      }

      return (crc ^ (-1)); // >>> 0;
    };


    var crc32_1 = crc32;

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    var messages = {
      2:      'need dictionary',     /* Z_NEED_DICT       2  */
      1:      'stream end',          /* Z_STREAM_END      1  */
      0:      '',                    /* Z_OK              0  */
      '-1':   'file error',          /* Z_ERRNO         (-1) */
      '-2':   'stream error',        /* Z_STREAM_ERROR  (-2) */
      '-3':   'data error',          /* Z_DATA_ERROR    (-3) */
      '-4':   'insufficient memory', /* Z_MEM_ERROR     (-4) */
      '-5':   'buffer error',        /* Z_BUF_ERROR     (-5) */
      '-6':   'incompatible version' /* Z_VERSION_ERROR (-6) */
    };

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    var constants = {

      /* Allowed flush values; see deflate() and inflate() below for details */
      Z_NO_FLUSH:         0,
      Z_PARTIAL_FLUSH:    1,
      Z_SYNC_FLUSH:       2,
      Z_FULL_FLUSH:       3,
      Z_FINISH:           4,
      Z_BLOCK:            5,
      Z_TREES:            6,

      /* Return codes for the compression/decompression functions. Negative values
      * are errors, positive values are used for special but normal events.
      */
      Z_OK:               0,
      Z_STREAM_END:       1,
      Z_NEED_DICT:        2,
      Z_ERRNO:           -1,
      Z_STREAM_ERROR:    -2,
      Z_DATA_ERROR:      -3,
      Z_MEM_ERROR:       -4,
      Z_BUF_ERROR:       -5,
      //Z_VERSION_ERROR: -6,

      /* compression levels */
      Z_NO_COMPRESSION:         0,
      Z_BEST_SPEED:             1,
      Z_BEST_COMPRESSION:       9,
      Z_DEFAULT_COMPRESSION:   -1,


      Z_FILTERED:               1,
      Z_HUFFMAN_ONLY:           2,
      Z_RLE:                    3,
      Z_FIXED:                  4,
      Z_DEFAULT_STRATEGY:       0,

      /* Possible values of the data_type field (though see inflate()) */
      Z_BINARY:                 0,
      Z_TEXT:                   1,
      //Z_ASCII:                1, // = Z_TEXT (deprecated)
      Z_UNKNOWN:                2,

      /* The deflate compression method */
      Z_DEFLATED:               8
      //Z_NULL:                 null // Use -1 or null inline, depending on var type
    };

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    const { _tr_init: _tr_init$1, _tr_stored_block: _tr_stored_block$1, _tr_flush_block: _tr_flush_block$1, _tr_tally: _tr_tally$1, _tr_align: _tr_align$1 } = trees;




    /* Public constants ==========================================================*/
    /* ===========================================================================*/

    const {
      Z_NO_FLUSH, Z_PARTIAL_FLUSH, Z_FULL_FLUSH, Z_FINISH, Z_BLOCK,
      Z_OK, Z_STREAM_END, Z_STREAM_ERROR, Z_DATA_ERROR, Z_BUF_ERROR,
      Z_DEFAULT_COMPRESSION,
      Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED: Z_FIXED$1, Z_DEFAULT_STRATEGY,
      Z_UNKNOWN: Z_UNKNOWN$1,
      Z_DEFLATED
    } = constants;

    /*============================================================================*/


    const MAX_MEM_LEVEL = 9;
    /* Maximum value for memLevel in deflateInit2 */
    const MAX_WBITS = 15;
    /* 32K LZ77 window */
    const DEF_MEM_LEVEL = 8;


    const LENGTH_CODES$1  = 29;
    /* number of length codes, not counting the special END_BLOCK code */
    const LITERALS$1      = 256;
    /* number of literal bytes 0..255 */
    const L_CODES$1       = LITERALS$1 + 1 + LENGTH_CODES$1;
    /* number of Literal or Length codes, including the END_BLOCK code */
    const D_CODES$1       = 30;
    /* number of distance codes */
    const BL_CODES$1      = 19;
    /* number of codes used to transfer the bit lengths */
    const HEAP_SIZE$1     = 2 * L_CODES$1 + 1;
    /* maximum heap size */
    const MAX_BITS$1  = 15;
    /* All codes must not exceed MAX_BITS bits */

    const MIN_MATCH$1 = 3;
    const MAX_MATCH$1 = 258;
    const MIN_LOOKAHEAD = (MAX_MATCH$1 + MIN_MATCH$1 + 1);

    const PRESET_DICT = 0x20;

    const INIT_STATE = 42;
    const EXTRA_STATE = 69;
    const NAME_STATE = 73;
    const COMMENT_STATE = 91;
    const HCRC_STATE = 103;
    const BUSY_STATE = 113;
    const FINISH_STATE = 666;

    const BS_NEED_MORE      = 1; /* block not completed, need more input or more output */
    const BS_BLOCK_DONE     = 2; /* block flush performed */
    const BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */
    const BS_FINISH_DONE    = 4; /* finish done, accept no more input or output */

    const OS_CODE = 0x03; // Unix :) . Don't detect, use this default.

    const err = (strm, errorCode) => {
      strm.msg = messages[errorCode];
      return errorCode;
    };

    const rank = (f) => {
      return ((f) << 1) - ((f) > 4 ? 9 : 0);
    };

    const zero$1 = (buf) => {
      let len = buf.length; while (--len >= 0) { buf[len] = 0; }
    };


    /* eslint-disable new-cap */
    let HASH_ZLIB = (s, prev, data) => ((prev << s.hash_shift) ^ data) & s.hash_mask;
    // This hash causes less collisions, https://github.com/nodeca/pako/issues/135
    // But breaks binary compatibility
    //let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;
    let HASH = HASH_ZLIB;

    /* =========================================================================
     * Flush as much pending output as possible. All deflate() output goes
     * through this function so some applications may wish to modify it
     * to avoid allocating a large strm->output buffer and copying into it.
     * (See also read_buf()).
     */
    const flush_pending = (strm) => {
      const s = strm.state;

      //_tr_flush_bits(s);
      let len = s.pending;
      if (len > strm.avail_out) {
        len = strm.avail_out;
      }
      if (len === 0) { return; }

      strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);
      strm.next_out += len;
      s.pending_out += len;
      strm.total_out += len;
      strm.avail_out -= len;
      s.pending -= len;
      if (s.pending === 0) {
        s.pending_out = 0;
      }
    };


    const flush_block_only = (s, last) => {
      _tr_flush_block$1(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
      s.block_start = s.strstart;
      flush_pending(s.strm);
    };


    const put_byte = (s, b) => {
      s.pending_buf[s.pending++] = b;
    };


    /* =========================================================================
     * Put a short in the pending buffer. The 16-bit value is put in MSB order.
     * IN assertion: the stream state is correct and there is enough room in
     * pending_buf.
     */
    const putShortMSB = (s, b) => {

      //  put_byte(s, (Byte)(b >> 8));
    //  put_byte(s, (Byte)(b & 0xff));
      s.pending_buf[s.pending++] = (b >>> 8) & 0xff;
      s.pending_buf[s.pending++] = b & 0xff;
    };


    /* ===========================================================================
     * Read a new buffer from the current input stream, update the adler32
     * and total number of bytes read.  All deflate() input goes through
     * this function so some applications may wish to modify it to avoid
     * allocating a large strm->input buffer and copying from it.
     * (See also flush_pending()).
     */
    const read_buf = (strm, buf, start, size) => {

      let len = strm.avail_in;

      if (len > size) { len = size; }
      if (len === 0) { return 0; }

      strm.avail_in -= len;

      // zmemcpy(buf, strm->next_in, len);
      buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);
      if (strm.state.wrap === 1) {
        strm.adler = adler32_1(strm.adler, buf, len, start);
      }

      else if (strm.state.wrap === 2) {
        strm.adler = crc32_1(strm.adler, buf, len, start);
      }

      strm.next_in += len;
      strm.total_in += len;

      return len;
    };


    /* ===========================================================================
     * Set match_start to the longest match starting at the given string and
     * return its length. Matches shorter or equal to prev_length are discarded,
     * in which case the result is equal to prev_length and match_start is
     * garbage.
     * IN assertions: cur_match is the head of the hash chain for the current
     *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
     * OUT assertion: the match length is not greater than s->lookahead.
     */
    const longest_match = (s, cur_match) => {

      let chain_length = s.max_chain_length;      /* max hash chain length */
      let scan = s.strstart; /* current string */
      let match;                       /* matched string */
      let len;                           /* length of current match */
      let best_len = s.prev_length;              /* best match length so far */
      let nice_match = s.nice_match;             /* stop if match long enough */
      const limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?
          s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;

      const _win = s.window; // shortcut

      const wmask = s.w_mask;
      const prev  = s.prev;

      /* Stop when cur_match becomes <= limit. To simplify the code,
       * we prevent matches with the string of window index 0.
       */

      const strend = s.strstart + MAX_MATCH$1;
      let scan_end1  = _win[scan + best_len - 1];
      let scan_end   = _win[scan + best_len];

      /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
       * It is easy to get rid of this optimization if necessary.
       */
      // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");

      /* Do not waste too much time if we already have a good match: */
      if (s.prev_length >= s.good_match) {
        chain_length >>= 2;
      }
      /* Do not look for matches beyond the end of the input. This is necessary
       * to make deflate deterministic.
       */
      if (nice_match > s.lookahead) { nice_match = s.lookahead; }

      // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");

      do {
        // Assert(cur_match < s->strstart, "no future");
        match = cur_match;

        /* Skip to next match if the match length cannot increase
         * or if the match length is less than 2.  Note that the checks below
         * for insufficient lookahead only occur occasionally for performance
         * reasons.  Therefore uninitialized memory will be accessed, and
         * conditional jumps will be made that depend on those values.
         * However the length of the match is limited to the lookahead, so
         * the output of deflate is not affected by the uninitialized values.
         */

        if (_win[match + best_len]     !== scan_end  ||
            _win[match + best_len - 1] !== scan_end1 ||
            _win[match]                !== _win[scan] ||
            _win[++match]              !== _win[scan + 1]) {
          continue;
        }

        /* The check at best_len-1 can be removed because it will be made
         * again later. (This heuristic is not always a win.)
         * It is not necessary to compare scan[2] and match[2] since they
         * are always equal when the other bytes match, given that
         * the hash keys are equal and that HASH_BITS >= 8.
         */
        scan += 2;
        match++;
        // Assert(*scan == *match, "match[2]?");

        /* We check for insufficient lookahead only every 8th comparison;
         * the 256th check will be made at strstart+258.
         */
        do {
          /*jshint noempty:false*/
        } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
                 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
                 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
                 _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
                 scan < strend);

        // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");

        len = MAX_MATCH$1 - (strend - scan);
        scan = strend - MAX_MATCH$1;

        if (len > best_len) {
          s.match_start = cur_match;
          best_len = len;
          if (len >= nice_match) {
            break;
          }
          scan_end1  = _win[scan + best_len - 1];
          scan_end   = _win[scan + best_len];
        }
      } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);

      if (best_len <= s.lookahead) {
        return best_len;
      }
      return s.lookahead;
    };


    /* ===========================================================================
     * Fill the window when the lookahead becomes insufficient.
     * Updates strstart and lookahead.
     *
     * IN assertion: lookahead < MIN_LOOKAHEAD
     * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
     *    At least one byte has been read, or avail_in == 0; reads are
     *    performed for at least two bytes (required for the zip translate_eol
     *    option -- not supported here).
     */
    const fill_window = (s) => {

      const _w_size = s.w_size;
      let p, n, m, more, str;

      //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");

      do {
        more = s.window_size - s.lookahead - s.strstart;

        // JS ints have 32 bit, block below not needed
        /* Deal with !@#$% 64K limit: */
        //if (sizeof(int) <= 2) {
        //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
        //        more = wsize;
        //
        //  } else if (more == (unsigned)(-1)) {
        //        /* Very unlikely, but possible on 16 bit machine if
        //         * strstart == 0 && lookahead == 1 (input done a byte at time)
        //         */
        //        more--;
        //    }
        //}


        /* If the window is almost full and there is insufficient lookahead,
         * move the upper half to the lower one to make room in the upper half.
         */
        if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {

          s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0);
          s.match_start -= _w_size;
          s.strstart -= _w_size;
          /* we now have strstart >= MAX_DIST */
          s.block_start -= _w_size;

          /* Slide the hash table (could be avoided with 32 bit values
           at the expense of memory usage). We slide even when level == 0
           to keep the hash table consistent if we switch back to level > 0
           later. (Using level 0 permanently is not an optimal usage of
           zlib, so we don't care about this pathological case.)
           */

          n = s.hash_size;
          p = n;

          do {
            m = s.head[--p];
            s.head[p] = (m >= _w_size ? m - _w_size : 0);
          } while (--n);

          n = _w_size;
          p = n;

          do {
            m = s.prev[--p];
            s.prev[p] = (m >= _w_size ? m - _w_size : 0);
            /* If n is not on any hash chain, prev[n] is garbage but
             * its value will never be used.
             */
          } while (--n);

          more += _w_size;
        }
        if (s.strm.avail_in === 0) {
          break;
        }

        /* If there was no sliding:
         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
         *    more == window_size - lookahead - strstart
         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
         * => more >= window_size - 2*WSIZE + 2
         * In the BIG_MEM or MMAP case (not yet supported),
         *   window_size == input_size + MIN_LOOKAHEAD  &&
         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
         * Otherwise, window_size == 2*WSIZE so more >= 2.
         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
         */
        //Assert(more >= 2, "more < 2");
        n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
        s.lookahead += n;

        /* Initialize the hash value now that we have some input: */
        if (s.lookahead + s.insert >= MIN_MATCH$1) {
          str = s.strstart - s.insert;
          s.ins_h = s.window[str];

          /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */
          s.ins_h = HASH(s, s.ins_h, s.window[str + 1]);
    //#if MIN_MATCH != 3
    //        Call update_hash() MIN_MATCH-3 more times
    //#endif
          while (s.insert) {
            /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
            s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);

            s.prev[str & s.w_mask] = s.head[s.ins_h];
            s.head[s.ins_h] = str;
            str++;
            s.insert--;
            if (s.lookahead + s.insert < MIN_MATCH$1) {
              break;
            }
          }
        }
        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
         * but this is not important since only literal bytes will be emitted.
         */

      } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);

      /* If the WIN_INIT bytes after the end of the current data have never been
       * written, then zero those bytes in order to avoid memory check reports of
       * the use of uninitialized (or uninitialised as Julian writes) bytes by
       * the longest match routines.  Update the high water mark for the next
       * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
       * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
       */
    //  if (s.high_water < s.window_size) {
    //    const curr = s.strstart + s.lookahead;
    //    let init = 0;
    //
    //    if (s.high_water < curr) {
    //      /* Previous high water mark below current data -- zero WIN_INIT
    //       * bytes or up to end of window, whichever is less.
    //       */
    //      init = s.window_size - curr;
    //      if (init > WIN_INIT)
    //        init = WIN_INIT;
    //      zmemzero(s->window + curr, (unsigned)init);
    //      s->high_water = curr + init;
    //    }
    //    else if (s->high_water < (ulg)curr + WIN_INIT) {
    //      /* High water mark at or above current data, but below current data
    //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
    //       * to end of window, whichever is less.
    //       */
    //      init = (ulg)curr + WIN_INIT - s->high_water;
    //      if (init > s->window_size - s->high_water)
    //        init = s->window_size - s->high_water;
    //      zmemzero(s->window + s->high_water, (unsigned)init);
    //      s->high_water += init;
    //    }
    //  }
    //
    //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
    //    "not enough room for search");
    };

    /* ===========================================================================
     * Copy without compression as much as possible from the input stream, return
     * the current block state.
     * This function does not insert new strings in the dictionary since
     * uncompressible data is probably not useful. This function is used
     * only for the level=0 compression option.
     * NOTE: this function should be optimized to avoid extra copying from
     * window to pending_buf.
     */
    const deflate_stored = (s, flush) => {

      /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
       * to pending_buf_size, and each stored block has a 5 byte header:
       */
      let max_block_size = 0xffff;

      if (max_block_size > s.pending_buf_size - 5) {
        max_block_size = s.pending_buf_size - 5;
      }

      /* Copy as much as possible from input to output: */
      for (;;) {
        /* Fill the window as much as possible: */
        if (s.lookahead <= 1) {

          //Assert(s->strstart < s->w_size+MAX_DIST(s) ||
          //  s->block_start >= (long)s->w_size, "slide too late");
    //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||
    //        s.block_start >= s.w_size)) {
    //        throw  new Error("slide too late");
    //      }

          fill_window(s);
          if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
            return BS_NEED_MORE;
          }

          if (s.lookahead === 0) {
            break;
          }
          /* flush the current block */
        }
        //Assert(s->block_start >= 0L, "block gone");
    //    if (s.block_start < 0) throw new Error("block gone");

        s.strstart += s.lookahead;
        s.lookahead = 0;

        /* Emit a stored block if pending_buf will be full: */
        const max_start = s.block_start + max_block_size;

        if (s.strstart === 0 || s.strstart >= max_start) {
          /* strstart == 0 is possible when wraparound on 16-bit machine */
          s.lookahead = s.strstart - max_start;
          s.strstart = max_start;
          /*** FLUSH_BLOCK(s, 0); ***/
          flush_block_only(s, false);
          if (s.strm.avail_out === 0) {
            return BS_NEED_MORE;
          }
          /***/


        }
        /* Flush if we may have to slide, otherwise block_start may become
         * negative and the data will be gone:
         */
        if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {
          /*** FLUSH_BLOCK(s, 0); ***/
          flush_block_only(s, false);
          if (s.strm.avail_out === 0) {
            return BS_NEED_MORE;
          }
          /***/
        }
      }

      s.insert = 0;

      if (flush === Z_FINISH) {
        /*** FLUSH_BLOCK(s, 1); ***/
        flush_block_only(s, true);
        if (s.strm.avail_out === 0) {
          return BS_FINISH_STARTED;
        }
        /***/
        return BS_FINISH_DONE;
      }

      if (s.strstart > s.block_start) {
        /*** FLUSH_BLOCK(s, 0); ***/
        flush_block_only(s, false);
        if (s.strm.avail_out === 0) {
          return BS_NEED_MORE;
        }
        /***/
      }

      return BS_NEED_MORE;
    };

    /* ===========================================================================
     * Compress as much as possible from the input stream, return the current
     * block state.
     * This function does not perform lazy evaluation of matches and inserts
     * new strings in the dictionary only for unmatched strings or for short
     * matches. It is used only for the fast compression options.
     */
    const deflate_fast = (s, flush) => {

      let hash_head;        /* head of the hash chain */
      let bflush;           /* set if current block must be flushed */

      for (;;) {
        /* Make sure that we always have enough lookahead, except
         * at the end of the input file. We need MAX_MATCH bytes
         * for the next match, plus MIN_MATCH bytes to insert the
         * string following the next match.
         */
        if (s.lookahead < MIN_LOOKAHEAD) {
          fill_window(s);
          if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
            return BS_NEED_MORE;
          }
          if (s.lookahead === 0) {
            break; /* flush the current block */
          }
        }

        /* Insert the string window[strstart .. strstart+2] in the
         * dictionary, and set hash_head to the head of the hash chain:
         */
        hash_head = 0/*NIL*/;
        if (s.lookahead >= MIN_MATCH$1) {
          /*** INSERT_STRING(s, s.strstart, hash_head); ***/
          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
          s.head[s.ins_h] = s.strstart;
          /***/
        }

        /* Find the longest match, discarding those <= prev_length.
         * At this point we have always match_length < MIN_MATCH
         */
        if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {
          /* To simplify the code, we prevent matches with the string
           * of window index 0 (in particular we have to avoid a match
           * of the string with itself at the start of the input file).
           */
          s.match_length = longest_match(s, hash_head);
          /* longest_match() sets match_start */
        }
        if (s.match_length >= MIN_MATCH$1) {
          // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only

          /*** _tr_tally_dist(s, s.strstart - s.match_start,
                         s.match_length - MIN_MATCH, bflush); ***/
          bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1);

          s.lookahead -= s.match_length;

          /* Insert new strings in the hash table only if the match length
           * is not too large. This saves time but degrades compression.
           */
          if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH$1) {
            s.match_length--; /* string at strstart already in table */
            do {
              s.strstart++;
              /*** INSERT_STRING(s, s.strstart, hash_head); ***/
              s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
              hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
              s.head[s.ins_h] = s.strstart;
              /***/
              /* strstart never exceeds WSIZE-MAX_MATCH, so there are
               * always MIN_MATCH bytes ahead.
               */
            } while (--s.match_length !== 0);
            s.strstart++;
          } else
          {
            s.strstart += s.match_length;
            s.match_length = 0;
            s.ins_h = s.window[s.strstart];
            /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);

    //#if MIN_MATCH != 3
    //                Call UPDATE_HASH() MIN_MATCH-3 more times
    //#endif
            /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
             * matter since it will be recomputed at next deflate call.
             */
          }
        } else {
          /* No match, output a literal byte */
          //Tracevv((stderr,"%c", s.window[s.strstart]));
          /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
          bflush = _tr_tally$1(s, 0, s.window[s.strstart]);

          s.lookahead--;
          s.strstart++;
        }
        if (bflush) {
          /*** FLUSH_BLOCK(s, 0); ***/
          flush_block_only(s, false);
          if (s.strm.avail_out === 0) {
            return BS_NEED_MORE;
          }
          /***/
        }
      }
      s.insert = ((s.strstart < (MIN_MATCH$1 - 1)) ? s.strstart : MIN_MATCH$1 - 1);
      if (flush === Z_FINISH) {
        /*** FLUSH_BLOCK(s, 1); ***/
        flush_block_only(s, true);
        if (s.strm.avail_out === 0) {
          return BS_FINISH_STARTED;
        }
        /***/
        return BS_FINISH_DONE;
      }
      if (s.last_lit) {
        /*** FLUSH_BLOCK(s, 0); ***/
        flush_block_only(s, false);
        if (s.strm.avail_out === 0) {
          return BS_NEED_MORE;
        }
        /***/
      }
      return BS_BLOCK_DONE;
    };

    /* ===========================================================================
     * Same as above, but achieves better compression. We use a lazy
     * evaluation for matches: a match is finally adopted only if there is
     * no better match at the next window position.
     */
    const deflate_slow = (s, flush) => {

      let hash_head;          /* head of hash chain */
      let bflush;              /* set if current block must be flushed */

      let max_insert;

      /* Process the input block. */
      for (;;) {
        /* Make sure that we always have enough lookahead, except
         * at the end of the input file. We need MAX_MATCH bytes
         * for the next match, plus MIN_MATCH bytes to insert the
         * string following the next match.
         */
        if (s.lookahead < MIN_LOOKAHEAD) {
          fill_window(s);
          if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
            return BS_NEED_MORE;
          }
          if (s.lookahead === 0) { break; } /* flush the current block */
        }

        /* Insert the string window[strstart .. strstart+2] in the
         * dictionary, and set hash_head to the head of the hash chain:
         */
        hash_head = 0/*NIL*/;
        if (s.lookahead >= MIN_MATCH$1) {
          /*** INSERT_STRING(s, s.strstart, hash_head); ***/
          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
          s.head[s.ins_h] = s.strstart;
          /***/
        }

        /* Find the longest match, discarding those <= prev_length.
         */
        s.prev_length = s.match_length;
        s.prev_match = s.match_start;
        s.match_length = MIN_MATCH$1 - 1;

        if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
            s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
          /* To simplify the code, we prevent matches with the string
           * of window index 0 (in particular we have to avoid a match
           * of the string with itself at the start of the input file).
           */
          s.match_length = longest_match(s, hash_head);
          /* longest_match() sets match_start */

          if (s.match_length <= 5 &&
             (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {

            /* If prev_match is also MIN_MATCH, match_start is garbage
             * but we will ignore the current match anyway.
             */
            s.match_length = MIN_MATCH$1 - 1;
          }
        }
        /* If there was a match at the previous step and the current
         * match is not better, output the previous match:
         */
        if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {
          max_insert = s.strstart + s.lookahead - MIN_MATCH$1;
          /* Do not insert strings in hash table beyond this. */

          //check_match(s, s.strstart-1, s.prev_match, s.prev_length);

          /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
                         s.prev_length - MIN_MATCH, bflush);***/
          bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1);
          /* Insert in hash table all strings up to the end of the match.
           * strstart-1 and strstart are already inserted. If there is not
           * enough lookahead, the last two strings are not inserted in
           * the hash table.
           */
          s.lookahead -= s.prev_length - 1;
          s.prev_length -= 2;
          do {
            if (++s.strstart <= max_insert) {
              /*** INSERT_STRING(s, s.strstart, hash_head); ***/
              s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
              hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
              s.head[s.ins_h] = s.strstart;
              /***/
            }
          } while (--s.prev_length !== 0);
          s.match_available = 0;
          s.match_length = MIN_MATCH$1 - 1;
          s.strstart++;

          if (bflush) {
            /*** FLUSH_BLOCK(s, 0); ***/
            flush_block_only(s, false);
            if (s.strm.avail_out === 0) {
              return BS_NEED_MORE;
            }
            /***/
          }

        } else if (s.match_available) {
          /* If there was no match at the previous position, output a
           * single literal. If there was a match but the current match
           * is longer, truncate the previous match to a single literal.
           */
          //Tracevv((stderr,"%c", s->window[s->strstart-1]));
          /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
          bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);

          if (bflush) {
            /*** FLUSH_BLOCK_ONLY(s, 0) ***/
            flush_block_only(s, false);
            /***/
          }
          s.strstart++;
          s.lookahead--;
          if (s.strm.avail_out === 0) {
            return BS_NEED_MORE;
          }
        } else {
          /* There is no previous match to compare with, wait for
           * the next step to decide.
           */
          s.match_available = 1;
          s.strstart++;
          s.lookahead--;
        }
      }
      //Assert (flush != Z_NO_FLUSH, "no flush?");
      if (s.match_available) {
        //Tracevv((stderr,"%c", s->window[s->strstart-1]));
        /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
        bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);

        s.match_available = 0;
      }
      s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;
      if (flush === Z_FINISH) {
        /*** FLUSH_BLOCK(s, 1); ***/
        flush_block_only(s, true);
        if (s.strm.avail_out === 0) {
          return BS_FINISH_STARTED;
        }
        /***/
        return BS_FINISH_DONE;
      }
      if (s.last_lit) {
        /*** FLUSH_BLOCK(s, 0); ***/
        flush_block_only(s, false);
        if (s.strm.avail_out === 0) {
          return BS_NEED_MORE;
        }
        /***/
      }

      return BS_BLOCK_DONE;
    };


    /* ===========================================================================
     * For Z_RLE, simply look for runs of bytes, generate matches only of distance
     * one.  Do not maintain a hash table.  (It will be regenerated if this run of
     * deflate switches away from Z_RLE.)
     */
    const deflate_rle = (s, flush) => {

      let bflush;            /* set if current block must be flushed */
      let prev;              /* byte at distance one to match */
      let scan, strend;      /* scan goes up to strend for length of run */

      const _win = s.window;

      for (;;) {
        /* Make sure that we always have enough lookahead, except
         * at the end of the input file. We need MAX_MATCH bytes
         * for the longest run, plus one for the unrolled loop.
         */
        if (s.lookahead <= MAX_MATCH$1) {
          fill_window(s);
          if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {
            return BS_NEED_MORE;
          }
          if (s.lookahead === 0) { break; } /* flush the current block */
        }

        /* See how many times the previous byte repeats */
        s.match_length = 0;
        if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {
          scan = s.strstart - 1;
          prev = _win[scan];
          if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
            strend = s.strstart + MAX_MATCH$1;
            do {
              /*jshint noempty:false*/
            } while (prev === _win[++scan] && prev === _win[++scan] &&
                     prev === _win[++scan] && prev === _win[++scan] &&
                     prev === _win[++scan] && prev === _win[++scan] &&
                     prev === _win[++scan] && prev === _win[++scan] &&
                     scan < strend);
            s.match_length = MAX_MATCH$1 - (strend - scan);
            if (s.match_length > s.lookahead) {
              s.match_length = s.lookahead;
            }
          }
          //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
        }

        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
        if (s.match_length >= MIN_MATCH$1) {
          //check_match(s, s.strstart, s.strstart - 1, s.match_length);

          /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
          bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1);

          s.lookahead -= s.match_length;
          s.strstart += s.match_length;
          s.match_length = 0;
        } else {
          /* No match, output a literal byte */
          //Tracevv((stderr,"%c", s->window[s->strstart]));
          /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
          bflush = _tr_tally$1(s, 0, s.window[s.strstart]);

          s.lookahead--;
          s.strstart++;
        }
        if (bflush) {
          /*** FLUSH_BLOCK(s, 0); ***/
          flush_block_only(s, false);
          if (s.strm.avail_out === 0) {
            return BS_NEED_MORE;
          }
          /***/
        }
      }
      s.insert = 0;
      if (flush === Z_FINISH) {
        /*** FLUSH_BLOCK(s, 1); ***/
        flush_block_only(s, true);
        if (s.strm.avail_out === 0) {
          return BS_FINISH_STARTED;
        }
        /***/
        return BS_FINISH_DONE;
      }
      if (s.last_lit) {
        /*** FLUSH_BLOCK(s, 0); ***/
        flush_block_only(s, false);
        if (s.strm.avail_out === 0) {
          return BS_NEED_MORE;
        }
        /***/
      }
      return BS_BLOCK_DONE;
    };

    /* ===========================================================================
     * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
     * (It will be regenerated if this run of deflate switches away from Huffman.)
     */
    const deflate_huff = (s, flush) => {

      let bflush;             /* set if current block must be flushed */

      for (;;) {
        /* Make sure that we have a literal to write. */
        if (s.lookahead === 0) {
          fill_window(s);
          if (s.lookahead === 0) {
            if (flush === Z_NO_FLUSH) {
              return BS_NEED_MORE;
            }
            break;      /* flush the current block */
          }
        }

        /* Output a literal byte */
        s.match_length = 0;
        //Tracevv((stderr,"%c", s->window[s->strstart]));
        /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
        bflush = _tr_tally$1(s, 0, s.window[s.strstart]);
        s.lookahead--;
        s.strstart++;
        if (bflush) {
          /*** FLUSH_BLOCK(s, 0); ***/
          flush_block_only(s, false);
          if (s.strm.avail_out === 0) {
            return BS_NEED_MORE;
          }
          /***/
        }
      }
      s.insert = 0;
      if (flush === Z_FINISH) {
        /*** FLUSH_BLOCK(s, 1); ***/
        flush_block_only(s, true);
        if (s.strm.avail_out === 0) {
          return BS_FINISH_STARTED;
        }
        /***/
        return BS_FINISH_DONE;
      }
      if (s.last_lit) {
        /*** FLUSH_BLOCK(s, 0); ***/
        flush_block_only(s, false);
        if (s.strm.avail_out === 0) {
          return BS_NEED_MORE;
        }
        /***/
      }
      return BS_BLOCK_DONE;
    };

    /* Values for max_lazy_match, good_match and max_chain_length, depending on
     * the desired pack level (0..9). The values given below have been tuned to
     * exclude worst case performance for pathological files. Better values may be
     * found for specific files.
     */
    function Config(good_length, max_lazy, nice_length, max_chain, func) {

      this.good_length = good_length;
      this.max_lazy = max_lazy;
      this.nice_length = nice_length;
      this.max_chain = max_chain;
      this.func = func;
    }

    const configuration_table = [
      /*      good lazy nice chain */
      new Config(0, 0, 0, 0, deflate_stored),          /* 0 store only */
      new Config(4, 4, 8, 4, deflate_fast),            /* 1 max speed, no lazy matches */
      new Config(4, 5, 16, 8, deflate_fast),           /* 2 */
      new Config(4, 6, 32, 32, deflate_fast),          /* 3 */

      new Config(4, 4, 16, 16, deflate_slow),          /* 4 lazy matches */
      new Config(8, 16, 32, 32, deflate_slow),         /* 5 */
      new Config(8, 16, 128, 128, deflate_slow),       /* 6 */
      new Config(8, 32, 128, 256, deflate_slow),       /* 7 */
      new Config(32, 128, 258, 1024, deflate_slow),    /* 8 */
      new Config(32, 258, 258, 4096, deflate_slow)     /* 9 max compression */
    ];


    /* ===========================================================================
     * Initialize the "longest match" routines for a new zlib stream
     */
    const lm_init = (s) => {

      s.window_size = 2 * s.w_size;

      /*** CLEAR_HASH(s); ***/
      zero$1(s.head); // Fill with NIL (= 0);

      /* Set the default configuration parameters:
       */
      s.max_lazy_match = configuration_table[s.level].max_lazy;
      s.good_match = configuration_table[s.level].good_length;
      s.nice_match = configuration_table[s.level].nice_length;
      s.max_chain_length = configuration_table[s.level].max_chain;

      s.strstart = 0;
      s.block_start = 0;
      s.lookahead = 0;
      s.insert = 0;
      s.match_length = s.prev_length = MIN_MATCH$1 - 1;
      s.match_available = 0;
      s.ins_h = 0;
    };


    function DeflateState() {
      this.strm = null;            /* pointer back to this zlib stream */
      this.status = 0;            /* as the name implies */
      this.pending_buf = null;      /* output still pending */
      this.pending_buf_size = 0;  /* size of pending_buf */
      this.pending_out = 0;       /* next pending byte to output to the stream */
      this.pending = 0;           /* nb of bytes in the pending buffer */
      this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
      this.gzhead = null;         /* gzip header information to write */
      this.gzindex = 0;           /* where in extra, name, or comment */
      this.method = Z_DEFLATED; /* can only be DEFLATED */
      this.last_flush = -1;   /* value of flush param for previous deflate call */

      this.w_size = 0;  /* LZ77 window size (32K by default) */
      this.w_bits = 0;  /* log2(w_size)  (8..16) */
      this.w_mask = 0;  /* w_size - 1 */

      this.window = null;
      /* Sliding window. Input bytes are read into the second half of the window,
       * and move to the first half later to keep a dictionary of at least wSize
       * bytes. With this organization, matches are limited to a distance of
       * wSize-MAX_MATCH bytes, but this ensures that IO is always
       * performed with a length multiple of the block size.
       */

      this.window_size = 0;
      /* Actual size of window: 2*wSize, except when the user input buffer
       * is directly used as sliding window.
       */

      this.prev = null;
      /* Link to older string with same hash index. To limit the size of this
       * array to 64K, this link is maintained only for the last 32K strings.
       * An index in this array is thus a window index modulo 32K.
       */

      this.head = null;   /* Heads of the hash chains or NIL. */

      this.ins_h = 0;       /* hash index of string to be inserted */
      this.hash_size = 0;   /* number of elements in hash table */
      this.hash_bits = 0;   /* log2(hash_size) */
      this.hash_mask = 0;   /* hash_size-1 */

      this.hash_shift = 0;
      /* Number of bits by which ins_h must be shifted at each input
       * step. It must be such that after MIN_MATCH steps, the oldest
       * byte no longer takes part in the hash key, that is:
       *   hash_shift * MIN_MATCH >= hash_bits
       */

      this.block_start = 0;
      /* Window position at the beginning of the current output block. Gets
       * negative when the window is moved backwards.
       */

      this.match_length = 0;      /* length of best match */
      this.prev_match = 0;        /* previous match */
      this.match_available = 0;   /* set if previous match exists */
      this.strstart = 0;          /* start of string to insert */
      this.match_start = 0;       /* start of matching string */
      this.lookahead = 0;         /* number of valid bytes ahead in window */

      this.prev_length = 0;
      /* Length of the best match at previous step. Matches not greater than this
       * are discarded. This is used in the lazy match evaluation.
       */

      this.max_chain_length = 0;
      /* To speed up deflation, hash chains are never searched beyond this
       * length.  A higher limit improves compression ratio but degrades the
       * speed.
       */

      this.max_lazy_match = 0;
      /* Attempt to find a better match only when the current match is strictly
       * smaller than this value. This mechanism is used only for compression
       * levels >= 4.
       */
      // That's alias to max_lazy_match, don't use directly
      //this.max_insert_length = 0;
      /* Insert new strings in the hash table only if the match length is not
       * greater than this length. This saves time but degrades compression.
       * max_insert_length is used only for compression levels <= 3.
       */

      this.level = 0;     /* compression level (1..9) */
      this.strategy = 0;  /* favor or force Huffman coding*/

      this.good_match = 0;
      /* Use a faster search when the previous match is longer than this */

      this.nice_match = 0; /* Stop searching when current match exceeds this */

                  /* used by trees.c: */

      /* Didn't use ct_data typedef below to suppress compiler warning */

      // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
      // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
      // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */

      // Use flat array of DOUBLE size, with interleaved fata,
      // because JS does not support effective
      this.dyn_ltree  = new Uint16Array(HEAP_SIZE$1 * 2);
      this.dyn_dtree  = new Uint16Array((2 * D_CODES$1 + 1) * 2);
      this.bl_tree    = new Uint16Array((2 * BL_CODES$1 + 1) * 2);
      zero$1(this.dyn_ltree);
      zero$1(this.dyn_dtree);
      zero$1(this.bl_tree);

      this.l_desc   = null;         /* desc. for literal tree */
      this.d_desc   = null;         /* desc. for distance tree */
      this.bl_desc  = null;         /* desc. for bit length tree */

      //ush bl_count[MAX_BITS+1];
      this.bl_count = new Uint16Array(MAX_BITS$1 + 1);
      /* number of codes at each bit length for an optimal tree */

      //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
      this.heap = new Uint16Array(2 * L_CODES$1 + 1);  /* heap used to build the Huffman trees */
      zero$1(this.heap);

      this.heap_len = 0;               /* number of elements in the heap */
      this.heap_max = 0;               /* element of largest frequency */
      /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
       * The same heap array is used to build all trees.
       */

      this.depth = new Uint16Array(2 * L_CODES$1 + 1); //uch depth[2*L_CODES+1];
      zero$1(this.depth);
      /* Depth of each subtree used as tie breaker for trees of equal frequency
       */

      this.l_buf = 0;          /* buffer index for literals or lengths */

      this.lit_bufsize = 0;
      /* Size of match buffer for literals/lengths.  There are 4 reasons for
       * limiting lit_bufsize to 64K:
       *   - frequencies can be kept in 16 bit counters
       *   - if compression is not successful for the first block, all input
       *     data is still in the window so we can still emit a stored block even
       *     when input comes from standard input.  (This can also be done for
       *     all blocks if lit_bufsize is not greater than 32K.)
       *   - if compression is not successful for a file smaller than 64K, we can
       *     even emit a stored file instead of a stored block (saving 5 bytes).
       *     This is applicable only for zip (not gzip or zlib).
       *   - creating new Huffman trees less frequently may not provide fast
       *     adaptation to changes in the input data statistics. (Take for
       *     example a binary file with poorly compressible code followed by
       *     a highly compressible string table.) Smaller buffer sizes give
       *     fast adaptation but have of course the overhead of transmitting
       *     trees more frequently.
       *   - I can't count above 4
       */

      this.last_lit = 0;      /* running index in l_buf */

      this.d_buf = 0;
      /* Buffer index for distances. To simplify the code, d_buf and l_buf have
       * the same number of elements. To use different lengths, an extra flag
       * array would be necessary.
       */

      this.opt_len = 0;       /* bit length of current block with optimal trees */
      this.static_len = 0;    /* bit length of current block with static trees */
      this.matches = 0;       /* number of string matches in current block */
      this.insert = 0;        /* bytes at end of window left to insert */


      this.bi_buf = 0;
      /* Output buffer. bits are inserted starting at the bottom (least
       * significant bits).
       */
      this.bi_valid = 0;
      /* Number of valid bits in bi_buf.  All bits above the last valid bit
       * are always zero.
       */

      // Used for window memory init. We safely ignore it for JS. That makes
      // sense only for pointers and memory check tools.
      //this.high_water = 0;
      /* High water mark offset in window for initialized bytes -- bytes above
       * this are set to zero in order to avoid memory check warnings when
       * longest match routines access bytes past the input.  This is then
       * updated to the new high water mark.
       */
    }


    const deflateResetKeep = (strm) => {

      if (!strm || !strm.state) {
        return err(strm, Z_STREAM_ERROR);
      }

      strm.total_in = strm.total_out = 0;
      strm.data_type = Z_UNKNOWN$1;

      const s = strm.state;
      s.pending = 0;
      s.pending_out = 0;

      if (s.wrap < 0) {
        s.wrap = -s.wrap;
        /* was made negative by deflate(..., Z_FINISH); */
      }
      s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
      strm.adler = (s.wrap === 2) ?
        0  // crc32(0, Z_NULL, 0)
      :
        1; // adler32(0, Z_NULL, 0)
      s.last_flush = Z_NO_FLUSH;
      _tr_init$1(s);
      return Z_OK;
    };


    const deflateReset = (strm) => {

      const ret = deflateResetKeep(strm);
      if (ret === Z_OK) {
        lm_init(strm.state);
      }
      return ret;
    };


    const deflateSetHeader = (strm, head) => {

      if (!strm || !strm.state) { return Z_STREAM_ERROR; }
      if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
      strm.state.gzhead = head;
      return Z_OK;
    };


    const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {

      if (!strm) { // === Z_NULL
        return Z_STREAM_ERROR;
      }
      let wrap = 1;

      if (level === Z_DEFAULT_COMPRESSION) {
        level = 6;
      }

      if (windowBits < 0) { /* suppress zlib wrapper */
        wrap = 0;
        windowBits = -windowBits;
      }

      else if (windowBits > 15) {
        wrap = 2;           /* write gzip wrapper instead */
        windowBits -= 16;
      }


      if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||
        windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
        strategy < 0 || strategy > Z_FIXED$1) {
        return err(strm, Z_STREAM_ERROR);
      }


      if (windowBits === 8) {
        windowBits = 9;
      }
      /* until 256-byte window bug fixed */

      const s = new DeflateState();

      strm.state = s;
      s.strm = strm;

      s.wrap = wrap;
      s.gzhead = null;
      s.w_bits = windowBits;
      s.w_size = 1 << s.w_bits;
      s.w_mask = s.w_size - 1;

      s.hash_bits = memLevel + 7;
      s.hash_size = 1 << s.hash_bits;
      s.hash_mask = s.hash_size - 1;
      s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1);

      s.window = new Uint8Array(s.w_size * 2);
      s.head = new Uint16Array(s.hash_size);
      s.prev = new Uint16Array(s.w_size);

      // Don't need mem init magic for JS.
      //s.high_water = 0;  /* nothing written to s->window yet */

      s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */

      s.pending_buf_size = s.lit_bufsize * 4;

      //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
      //s->pending_buf = (uchf *) overlay;
      s.pending_buf = new Uint8Array(s.pending_buf_size);

      // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)
      //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
      s.d_buf = 1 * s.lit_bufsize;

      //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
      s.l_buf = (1 + 2) * s.lit_bufsize;

      s.level = level;
      s.strategy = strategy;
      s.method = method;

      return deflateReset(strm);
    };

    const deflateInit = (strm, level) => {

      return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
    };


    const deflate = (strm, flush) => {

      let beg, val; // for gzip header write only

      if (!strm || !strm.state ||
        flush > Z_BLOCK || flush < 0) {
        return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
      }

      const s = strm.state;

      if (!strm.output ||
          (!strm.input && strm.avail_in !== 0) ||
          (s.status === FINISH_STATE && flush !== Z_FINISH)) {
        return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
      }

      s.strm = strm; /* just in case */
      const old_flush = s.last_flush;
      s.last_flush = flush;

      /* Write the header */
      if (s.status === INIT_STATE) {

        if (s.wrap === 2) { // GZIP header
          strm.adler = 0;  //crc32(0L, Z_NULL, 0);
          put_byte(s, 31);
          put_byte(s, 139);
          put_byte(s, 8);
          if (!s.gzhead) { // s->gzhead == Z_NULL
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, s.level === 9 ? 2 :
                        (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
                         4 : 0));
            put_byte(s, OS_CODE);
            s.status = BUSY_STATE;
          }
          else {
            put_byte(s, (s.gzhead.text ? 1 : 0) +
                        (s.gzhead.hcrc ? 2 : 0) +
                        (!s.gzhead.extra ? 0 : 4) +
                        (!s.gzhead.name ? 0 : 8) +
                        (!s.gzhead.comment ? 0 : 16)
            );
            put_byte(s, s.gzhead.time & 0xff);
            put_byte(s, (s.gzhead.time >> 8) & 0xff);
            put_byte(s, (s.gzhead.time >> 16) & 0xff);
            put_byte(s, (s.gzhead.time >> 24) & 0xff);
            put_byte(s, s.level === 9 ? 2 :
                        (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
                         4 : 0));
            put_byte(s, s.gzhead.os & 0xff);
            if (s.gzhead.extra && s.gzhead.extra.length) {
              put_byte(s, s.gzhead.extra.length & 0xff);
              put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
            }
            if (s.gzhead.hcrc) {
              strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);
            }
            s.gzindex = 0;
            s.status = EXTRA_STATE;
          }
        }
        else // DEFLATE header
        {
          let header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
          let level_flags = -1;

          if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
            level_flags = 0;
          } else if (s.level < 6) {
            level_flags = 1;
          } else if (s.level === 6) {
            level_flags = 2;
          } else {
            level_flags = 3;
          }
          header |= (level_flags << 6);
          if (s.strstart !== 0) { header |= PRESET_DICT; }
          header += 31 - (header % 31);

          s.status = BUSY_STATE;
          putShortMSB(s, header);

          /* Save the adler32 of the preset dictionary: */
          if (s.strstart !== 0) {
            putShortMSB(s, strm.adler >>> 16);
            putShortMSB(s, strm.adler & 0xffff);
          }
          strm.adler = 1; // adler32(0L, Z_NULL, 0);
        }
      }

    //#ifdef GZIP
      if (s.status === EXTRA_STATE) {
        if (s.gzhead.extra/* != Z_NULL*/) {
          beg = s.pending;  /* start of bytes to update crc */

          while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
            if (s.pending === s.pending_buf_size) {
              if (s.gzhead.hcrc && s.pending > beg) {
                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
              }
              flush_pending(strm);
              beg = s.pending;
              if (s.pending === s.pending_buf_size) {
                break;
              }
            }
            put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
            s.gzindex++;
          }
          if (s.gzhead.hcrc && s.pending > beg) {
            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
          }
          if (s.gzindex === s.gzhead.extra.length) {
            s.gzindex = 0;
            s.status = NAME_STATE;
          }
        }
        else {
          s.status = NAME_STATE;
        }
      }
      if (s.status === NAME_STATE) {
        if (s.gzhead.name/* != Z_NULL*/) {
          beg = s.pending;  /* start of bytes to update crc */
          //int val;

          do {
            if (s.pending === s.pending_buf_size) {
              if (s.gzhead.hcrc && s.pending > beg) {
                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
              }
              flush_pending(strm);
              beg = s.pending;
              if (s.pending === s.pending_buf_size) {
                val = 1;
                break;
              }
            }
            // JS specific: little magic to add zero terminator to end of string
            if (s.gzindex < s.gzhead.name.length) {
              val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;
            } else {
              val = 0;
            }
            put_byte(s, val);
          } while (val !== 0);

          if (s.gzhead.hcrc && s.pending > beg) {
            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
          }
          if (val === 0) {
            s.gzindex = 0;
            s.status = COMMENT_STATE;
          }
        }
        else {
          s.status = COMMENT_STATE;
        }
      }
      if (s.status === COMMENT_STATE) {
        if (s.gzhead.comment/* != Z_NULL*/) {
          beg = s.pending;  /* start of bytes to update crc */
          //int val;

          do {
            if (s.pending === s.pending_buf_size) {
              if (s.gzhead.hcrc && s.pending > beg) {
                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
              }
              flush_pending(strm);
              beg = s.pending;
              if (s.pending === s.pending_buf_size) {
                val = 1;
                break;
              }
            }
            // JS specific: little magic to add zero terminator to end of string
            if (s.gzindex < s.gzhead.comment.length) {
              val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;
            } else {
              val = 0;
            }
            put_byte(s, val);
          } while (val !== 0);

          if (s.gzhead.hcrc && s.pending > beg) {
            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
          }
          if (val === 0) {
            s.status = HCRC_STATE;
          }
        }
        else {
          s.status = HCRC_STATE;
        }
      }
      if (s.status === HCRC_STATE) {
        if (s.gzhead.hcrc) {
          if (s.pending + 2 > s.pending_buf_size) {
            flush_pending(strm);
          }
          if (s.pending + 2 <= s.pending_buf_size) {
            put_byte(s, strm.adler & 0xff);
            put_byte(s, (strm.adler >> 8) & 0xff);
            strm.adler = 0; //crc32(0L, Z_NULL, 0);
            s.status = BUSY_STATE;
          }
        }
        else {
          s.status = BUSY_STATE;
        }
      }
    //#endif

      /* Flush as much pending output as possible */
      if (s.pending !== 0) {
        flush_pending(strm);
        if (strm.avail_out === 0) {
          /* Since avail_out is 0, deflate will be called again with
           * more output space, but possibly with both pending and
           * avail_in equal to zero. There won't be anything to do,
           * but this is not an error situation so make sure we
           * return OK instead of BUF_ERROR at next call of deflate:
           */
          s.last_flush = -1;
          return Z_OK;
        }

        /* Make sure there is something to do and avoid duplicate consecutive
         * flushes. For repeated and useless calls with Z_FINISH, we keep
         * returning Z_STREAM_END instead of Z_BUF_ERROR.
         */
      } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
        flush !== Z_FINISH) {
        return err(strm, Z_BUF_ERROR);
      }

      /* User must not provide more input after the first FINISH: */
      if (s.status === FINISH_STATE && strm.avail_in !== 0) {
        return err(strm, Z_BUF_ERROR);
      }

      /* Start a new block or continue the current one.
       */
      if (strm.avail_in !== 0 || s.lookahead !== 0 ||
        (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {
        let bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :
          (s.strategy === Z_RLE ? deflate_rle(s, flush) :
            configuration_table[s.level].func(s, flush));

        if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
          s.status = FINISH_STATE;
        }
        if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
          if (strm.avail_out === 0) {
            s.last_flush = -1;
            /* avoid BUF_ERROR next call, see above */
          }
          return Z_OK;
          /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
           * of deflate should use the same flush parameter to make sure
           * that the flush is complete. So we don't have to output an
           * empty block here, this will be done at next call. This also
           * ensures that for a very small output buffer, we emit at most
           * one empty block.
           */
        }
        if (bstate === BS_BLOCK_DONE) {
          if (flush === Z_PARTIAL_FLUSH) {
            _tr_align$1(s);
          }
          else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */

            _tr_stored_block$1(s, 0, 0, false);
            /* For a full flush, this empty block will be recognized
             * as a special marker by inflate_sync().
             */
            if (flush === Z_FULL_FLUSH) {
              /*** CLEAR_HASH(s); ***/             /* forget history */
              zero$1(s.head); // Fill with NIL (= 0);

              if (s.lookahead === 0) {
                s.strstart = 0;
                s.block_start = 0;
                s.insert = 0;
              }
            }
          }
          flush_pending(strm);
          if (strm.avail_out === 0) {
            s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */
            return Z_OK;
          }
        }
      }
      //Assert(strm->avail_out > 0, "bug2");
      //if (strm.avail_out <= 0) { throw new Error("bug2");}

      if (flush !== Z_FINISH) { return Z_OK; }
      if (s.wrap <= 0) { return Z_STREAM_END; }

      /* Write the trailer */
      if (s.wrap === 2) {
        put_byte(s, strm.adler & 0xff);
        put_byte(s, (strm.adler >> 8) & 0xff);
        put_byte(s, (strm.adler >> 16) & 0xff);
        put_byte(s, (strm.adler >> 24) & 0xff);
        put_byte(s, strm.total_in & 0xff);
        put_byte(s, (strm.total_in >> 8) & 0xff);
        put_byte(s, (strm.total_in >> 16) & 0xff);
        put_byte(s, (strm.total_in >> 24) & 0xff);
      }
      else
      {
        putShortMSB(s, strm.adler >>> 16);
        putShortMSB(s, strm.adler & 0xffff);
      }

      flush_pending(strm);
      /* If avail_out is zero, the application will call deflate again
       * to flush the rest.
       */
      if (s.wrap > 0) { s.wrap = -s.wrap; }
      /* write the trailer only once! */
      return s.pending !== 0 ? Z_OK : Z_STREAM_END;
    };


    const deflateEnd = (strm) => {

      if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
        return Z_STREAM_ERROR;
      }

      const status = strm.state.status;
      if (status !== INIT_STATE &&
        status !== EXTRA_STATE &&
        status !== NAME_STATE &&
        status !== COMMENT_STATE &&
        status !== HCRC_STATE &&
        status !== BUSY_STATE &&
        status !== FINISH_STATE
      ) {
        return err(strm, Z_STREAM_ERROR);
      }

      strm.state = null;

      return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
    };


    /* =========================================================================
     * Initializes the compression dictionary from the given byte
     * sequence without producing any compressed output.
     */
    const deflateSetDictionary = (strm, dictionary) => {

      let dictLength = dictionary.length;

      if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
        return Z_STREAM_ERROR;
      }

      const s = strm.state;
      const wrap = s.wrap;

      if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
        return Z_STREAM_ERROR;
      }

      /* when using zlib wrappers, compute Adler-32 for provided dictionary */
      if (wrap === 1) {
        /* adler32(strm->adler, dictionary, dictLength); */
        strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);
      }

      s.wrap = 0;   /* avoid computing Adler-32 in read_buf */

      /* if dictionary would fill window, just replace the history */
      if (dictLength >= s.w_size) {
        if (wrap === 0) {            /* already empty otherwise */
          /*** CLEAR_HASH(s); ***/
          zero$1(s.head); // Fill with NIL (= 0);
          s.strstart = 0;
          s.block_start = 0;
          s.insert = 0;
        }
        /* use the tail */
        // dictionary = dictionary.slice(dictLength - s.w_size);
        let tmpDict = new Uint8Array(s.w_size);
        tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);
        dictionary = tmpDict;
        dictLength = s.w_size;
      }
      /* insert dictionary into window and hash */
      const avail = strm.avail_in;
      const next = strm.next_in;
      const input = strm.input;
      strm.avail_in = dictLength;
      strm.next_in = 0;
      strm.input = dictionary;
      fill_window(s);
      while (s.lookahead >= MIN_MATCH$1) {
        let str = s.strstart;
        let n = s.lookahead - (MIN_MATCH$1 - 1);
        do {
          /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
          s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);

          s.prev[str & s.w_mask] = s.head[s.ins_h];

          s.head[s.ins_h] = str;
          str++;
        } while (--n);
        s.strstart = str;
        s.lookahead = MIN_MATCH$1 - 1;
        fill_window(s);
      }
      s.strstart += s.lookahead;
      s.block_start = s.strstart;
      s.insert = s.lookahead;
      s.lookahead = 0;
      s.match_length = s.prev_length = MIN_MATCH$1 - 1;
      s.match_available = 0;
      strm.next_in = next;
      strm.input = input;
      strm.avail_in = avail;
      s.wrap = wrap;
      return Z_OK;
    };


    var deflateInit_1 = deflateInit;
    var deflateInit2_1 = deflateInit2;
    var deflateReset_1 = deflateReset;
    var deflateResetKeep_1 = deflateResetKeep;
    var deflateSetHeader_1 = deflateSetHeader;
    var deflate_2 = deflate;
    var deflateEnd_1 = deflateEnd;
    var deflateSetDictionary_1 = deflateSetDictionary;
    var deflateInfo = 'pako deflate (from Nodeca project)';

    /* Not implemented
    module.exports.deflateBound = deflateBound;
    module.exports.deflateCopy = deflateCopy;
    module.exports.deflateParams = deflateParams;
    module.exports.deflatePending = deflatePending;
    module.exports.deflatePrime = deflatePrime;
    module.exports.deflateTune = deflateTune;
    */

    var deflate_1 = {
        deflateInit: deflateInit_1,
        deflateInit2: deflateInit2_1,
        deflateReset: deflateReset_1,
        deflateResetKeep: deflateResetKeep_1,
        deflateSetHeader: deflateSetHeader_1,
        deflate: deflate_2,
        deflateEnd: deflateEnd_1,
        deflateSetDictionary: deflateSetDictionary_1,
        deflateInfo: deflateInfo
    };

    const _has = (obj, key) => {
      return Object.prototype.hasOwnProperty.call(obj, key);
    };

    var assign = function (obj /*from1, from2, from3, ...*/) {
      const sources = Array.prototype.slice.call(arguments, 1);
      while (sources.length) {
        const source = sources.shift();
        if (!source) { continue; }

        if (typeof source !== 'object') {
          throw new TypeError(source + 'must be non-object');
        }

        for (const p in source) {
          if (_has(source, p)) {
            obj[p] = source[p];
          }
        }
      }

      return obj;
    };


    // Join array of chunks to single array.
    var flattenChunks = (chunks) => {
      // calculate data length
      let len = 0;

      for (let i = 0, l = chunks.length; i < l; i++) {
        len += chunks[i].length;
      }

      // join chunks
      const result = new Uint8Array(len);

      for (let i = 0, pos = 0, l = chunks.length; i < l; i++) {
        let chunk = chunks[i];
        result.set(chunk, pos);
        pos += chunk.length;
      }

      return result;
    };

    var common = {
        assign: assign,
        flattenChunks: flattenChunks
    };

    // String encode/decode helpers


    // Quick check if we can use fast array to bin string conversion
    //
    // - apply(Array) can fail on Android 2.2
    // - apply(Uint8Array) can fail on iOS 5.1 Safari
    //
    let STR_APPLY_UIA_OK = true;

    try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }


    // Table with utf8 lengths (calculated by first byte of sequence)
    // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
    // because max possible codepoint is 0x10ffff
    const _utf8len = new Uint8Array(256);
    for (let q = 0; q < 256; q++) {
      _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
    }
    _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start


    // convert string to array (typed, when possible)
    var string2buf = (str) => {
      let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;

      // count binary size
      for (m_pos = 0; m_pos < str_len; m_pos++) {
        c = str.charCodeAt(m_pos);
        if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
          c2 = str.charCodeAt(m_pos + 1);
          if ((c2 & 0xfc00) === 0xdc00) {
            c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
            m_pos++;
          }
        }
        buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
      }

      // allocate buffer
      buf = new Uint8Array(buf_len);

      // convert
      for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
        c = str.charCodeAt(m_pos);
        if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
          c2 = str.charCodeAt(m_pos + 1);
          if ((c2 & 0xfc00) === 0xdc00) {
            c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
            m_pos++;
          }
        }
        if (c < 0x80) {
          /* one byte */
          buf[i++] = c;
        } else if (c < 0x800) {
          /* two bytes */
          buf[i++] = 0xC0 | (c >>> 6);
          buf[i++] = 0x80 | (c & 0x3f);
        } else if (c < 0x10000) {
          /* three bytes */
          buf[i++] = 0xE0 | (c >>> 12);
          buf[i++] = 0x80 | (c >>> 6 & 0x3f);
          buf[i++] = 0x80 | (c & 0x3f);
        } else {
          /* four bytes */
          buf[i++] = 0xf0 | (c >>> 18);
          buf[i++] = 0x80 | (c >>> 12 & 0x3f);
          buf[i++] = 0x80 | (c >>> 6 & 0x3f);
          buf[i++] = 0x80 | (c & 0x3f);
        }
      }

      return buf;
    };

    // Helper
    const buf2binstring = (buf, len) => {
      // On Chrome, the arguments in a function call that are allowed is `65534`.
      // If the length of the buffer is smaller than that, we can use this optimization,
      // otherwise we will take a slower path.
      if (len < 65534) {
        if (buf.subarray && STR_APPLY_UIA_OK) {
          return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));
        }
      }

      let result = '';
      for (let i = 0; i < len; i++) {
        result += String.fromCharCode(buf[i]);
      }
      return result;
    };


    // convert array to string
    var buf2string = (buf, max) => {
      let i, out;
      const len = max || buf.length;

      // Reserve max possible length (2 words per char)
      // NB: by unknown reasons, Array is significantly faster for
      //     String.fromCharCode.apply than Uint16Array.
      const utf16buf = new Array(len * 2);

      for (out = 0, i = 0; i < len;) {
        let c = buf[i++];
        // quick process ascii
        if (c < 0x80) { utf16buf[out++] = c; continue; }

        let c_len = _utf8len[c];
        // skip 5 & 6 byte codes
        if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }

        // apply mask on first byte
        c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
        // join the rest
        while (c_len > 1 && i < len) {
          c = (c << 6) | (buf[i++] & 0x3f);
          c_len--;
        }

        // terminated by end of string?
        if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }

        if (c < 0x10000) {
          utf16buf[out++] = c;
        } else {
          c -= 0x10000;
          utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
          utf16buf[out++] = 0xdc00 | (c & 0x3ff);
        }
      }

      return buf2binstring(utf16buf, out);
    };


    // Calculate max possible position in utf8 buffer,
    // that will not break sequence. If that's not possible
    // - (very small limits) return max size as is.
    //
    // buf[] - utf8 bytes array
    // max   - length limit (mandatory);
    var utf8border = (buf, max) => {

      max = max || buf.length;
      if (max > buf.length) { max = buf.length; }

      // go back from last position, until start of sequence found
      let pos = max - 1;
      while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }

      // Very small and broken sequence,
      // return max, because we should return something anyway.
      if (pos < 0) { return max; }

      // If we came to start of buffer - that means buffer is too small,
      // return max too.
      if (pos === 0) { return max; }

      return (pos + _utf8len[buf[pos]] > max) ? pos : max;
    };

    var strings = {
        string2buf: string2buf,
        buf2string: buf2string,
        utf8border: utf8border
    };

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    function ZStream() {
      /* next input byte */
      this.input = null; // JS specific, because we have no pointers
      this.next_in = 0;
      /* number of bytes available at input */
      this.avail_in = 0;
      /* total number of input bytes read so far */
      this.total_in = 0;
      /* next output byte should be put there */
      this.output = null; // JS specific, because we have no pointers
      this.next_out = 0;
      /* remaining free space at output */
      this.avail_out = 0;
      /* total number of bytes output so far */
      this.total_out = 0;
      /* last error message, NULL if no error */
      this.msg = ''/*Z_NULL*/;
      /* not visible by applications */
      this.state = null;
      /* best guess about the data type: binary or text */
      this.data_type = 2/*Z_UNKNOWN*/;
      /* adler32 value of the uncompressed data */
      this.adler = 0;
    }

    var zstream = ZStream;

    const toString = Object.prototype.toString;

    /* Public constants ==========================================================*/
    /* ===========================================================================*/

    const {
      Z_NO_FLUSH: Z_NO_FLUSH$1, Z_SYNC_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$1,
      Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1,
      Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1,
      Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1,
      Z_DEFLATED: Z_DEFLATED$1
    } = constants;

    /* ===========================================================================*/


    /**
     * class Deflate
     *
     * Generic JS-style wrapper for zlib calls. If you don't need
     * streaming behaviour - use more simple functions: [[deflate]],
     * [[deflateRaw]] and [[gzip]].
     **/

    /* internal
     * Deflate.chunks -> Array
     *
     * Chunks of output data, if [[Deflate#onData]] not overridden.
     **/

    /**
     * Deflate.result -> Uint8Array
     *
     * Compressed result, generated by default [[Deflate#onData]]
     * and [[Deflate#onEnd]] handlers. Filled after you push last chunk
     * (call [[Deflate#push]] with `Z_FINISH` / `true` param).
     **/

    /**
     * Deflate.err -> Number
     *
     * Error code after deflate finished. 0 (Z_OK) on success.
     * You will not need it in real life, because deflate errors
     * are possible only on wrong options or bad `onData` / `onEnd`
     * custom handlers.
     **/

    /**
     * Deflate.msg -> String
     *
     * Error message, if [[Deflate.err]] != 0
     **/


    /**
     * new Deflate(options)
     * - options (Object): zlib deflate options.
     *
     * Creates new deflator instance with specified params. Throws exception
     * on bad params. Supported options:
     *
     * - `level`
     * - `windowBits`
     * - `memLevel`
     * - `strategy`
     * - `dictionary`
     *
     * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
     * for more information on these.
     *
     * Additional options, for internal needs:
     *
     * - `chunkSize` - size of generated data chunks (16K by default)
     * - `raw` (Boolean) - do raw deflate
     * - `gzip` (Boolean) - create gzip wrapper
     * - `header` (Object) - custom header for gzip
     *   - `text` (Boolean) - true if compressed data believed to be text
     *   - `time` (Number) - modification time, unix timestamp
     *   - `os` (Number) - operation system code
     *   - `extra` (Array) - array of bytes with extra data (max 65536)
     *   - `name` (String) - file name (binary string)
     *   - `comment` (String) - comment (binary string)
     *   - `hcrc` (Boolean) - true if header crc should be added
     *
     * ##### Example:
     *
     * ```javascript
     * const pako = require('pako')
     *   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])
     *   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);
     *
     * const deflate = new pako.Deflate({ level: 3});
     *
     * deflate.push(chunk1, false);
     * deflate.push(chunk2, true);  // true -> last chunk
     *
     * if (deflate.err) { throw new Error(deflate.err); }
     *
     * console.log(deflate.result);
     * ```
     **/
    function Deflate(options) {
      this.options = common.assign({
        level: Z_DEFAULT_COMPRESSION$1,
        method: Z_DEFLATED$1,
        chunkSize: 16384,
        windowBits: 15,
        memLevel: 8,
        strategy: Z_DEFAULT_STRATEGY$1
      }, options || {});

      let opt = this.options;

      if (opt.raw && (opt.windowBits > 0)) {
        opt.windowBits = -opt.windowBits;
      }

      else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {
        opt.windowBits += 16;
      }

      this.err    = 0;      // error code, if happens (0 = Z_OK)
      this.msg    = '';     // error message
      this.ended  = false;  // used to avoid multiple onEnd() calls
      this.chunks = [];     // chunks of compressed data

      this.strm = new zstream();
      this.strm.avail_out = 0;

      let status = deflate_1.deflateInit2(
        this.strm,
        opt.level,
        opt.method,
        opt.windowBits,
        opt.memLevel,
        opt.strategy
      );

      if (status !== Z_OK$1) {
        throw new Error(messages[status]);
      }

      if (opt.header) {
        deflate_1.deflateSetHeader(this.strm, opt.header);
      }

      if (opt.dictionary) {
        let dict;
        // Convert data if needed
        if (typeof opt.dictionary === 'string') {
          // If we need to compress text, change encoding to utf8.
          dict = strings.string2buf(opt.dictionary);
        } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
          dict = new Uint8Array(opt.dictionary);
        } else {
          dict = opt.dictionary;
        }

        status = deflate_1.deflateSetDictionary(this.strm, dict);

        if (status !== Z_OK$1) {
          throw new Error(messages[status]);
        }

        this._dict_set = true;
      }
    }

    /**
     * Deflate#push(data[, flush_mode]) -> Boolean
     * - data (Uint8Array|ArrayBuffer|String): input data. Strings will be
     *   converted to utf8 byte sequence.
     * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
     *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.
     *
     * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
     * new compressed chunks. Returns `true` on success. The last data block must
     * have `flush_mode` Z_FINISH (or `true`). That will flush internal pending
     * buffers and call [[Deflate#onEnd]].
     *
     * On fail call [[Deflate#onEnd]] with error code and return false.
     *
     * ##### Example
     *
     * ```javascript
     * push(chunk, false); // push one of data chunks
     * ...
     * push(chunk, true);  // push last chunk
     * ```
     **/
    Deflate.prototype.push = function (data, flush_mode) {
      const strm = this.strm;
      const chunkSize = this.options.chunkSize;
      let status, _flush_mode;

      if (this.ended) { return false; }

      if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;
      else _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1;

      // Convert data if needed
      if (typeof data === 'string') {
        // If we need to compress text, change encoding to utf8.
        strm.input = strings.string2buf(data);
      } else if (toString.call(data) === '[object ArrayBuffer]') {
        strm.input = new Uint8Array(data);
      } else {
        strm.input = data;
      }

      strm.next_in = 0;
      strm.avail_in = strm.input.length;

      for (;;) {
        if (strm.avail_out === 0) {
          strm.output = new Uint8Array(chunkSize);
          strm.next_out = 0;
          strm.avail_out = chunkSize;
        }

        // Make sure avail_out > 6 to avoid repeating markers
        if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {
          this.onData(strm.output.subarray(0, strm.next_out));
          strm.avail_out = 0;
          continue;
        }

        status = deflate_1.deflate(strm, _flush_mode);

        // Ended => flush and finish
        if (status === Z_STREAM_END$1) {
          if (strm.next_out > 0) {
            this.onData(strm.output.subarray(0, strm.next_out));
          }
          status = deflate_1.deflateEnd(this.strm);
          this.onEnd(status);
          this.ended = true;
          return status === Z_OK$1;
        }

        // Flush if out buffer full
        if (strm.avail_out === 0) {
          this.onData(strm.output);
          continue;
        }

        // Flush if requested and has data
        if (_flush_mode > 0 && strm.next_out > 0) {
          this.onData(strm.output.subarray(0, strm.next_out));
          strm.avail_out = 0;
          continue;
        }

        if (strm.avail_in === 0) break;
      }

      return true;
    };


    /**
     * Deflate#onData(chunk) -> Void
     * - chunk (Uint8Array): output data.
     *
     * By default, stores data blocks in `chunks[]` property and glue
     * those in `onEnd`. Override this handler, if you need another behaviour.
     **/
    Deflate.prototype.onData = function (chunk) {
      this.chunks.push(chunk);
    };


    /**
     * Deflate#onEnd(status) -> Void
     * - status (Number): deflate status. 0 (Z_OK) on success,
     *   other if not.
     *
     * Called once after you tell deflate that the input stream is
     * complete (Z_FINISH). By default - join collected chunks,
     * free memory and fill `results` / `err` properties.
     **/
    Deflate.prototype.onEnd = function (status) {
      // On success - join
      if (status === Z_OK$1) {
        this.result = common.flattenChunks(this.chunks);
      }
      this.chunks = [];
      this.err = status;
      this.msg = this.strm.msg;
    };

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    // See state defs from inflate.js
    const BAD = 30;       /* got a data error -- remain here until reset */
    const TYPE = 12;      /* i: waiting for type bits, including last-flag bit */

    /*
       Decode literal, length, and distance codes and write out the resulting
       literal and match bytes until either not enough input or output is
       available, an end-of-block is encountered, or a data error is encountered.
       When large enough input and output buffers are supplied to inflate(), for
       example, a 16K input buffer and a 64K output buffer, more than 95% of the
       inflate execution time is spent in this routine.

       Entry assumptions:

            state.mode === LEN
            strm.avail_in >= 6
            strm.avail_out >= 258
            start >= strm.avail_out
            state.bits < 8

       On return, state.mode is one of:

            LEN -- ran out of enough output space or enough available input
            TYPE -- reached end of block code, inflate() to interpret next block
            BAD -- error in block data

       Notes:

        - The maximum input bits used by a length/distance pair is 15 bits for the
          length code, 5 bits for the length extra, 15 bits for the distance code,
          and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
          Therefore if strm.avail_in >= 6, then there is enough input to avoid
          checking for available input while decoding.

        - The maximum bytes that a single length/distance pair can output is 258
          bytes, which is the maximum length that can be coded.  inflate_fast()
          requires strm.avail_out >= 258 for each loop to avoid checking for
          output space.
     */
    var inffast = function inflate_fast(strm, start) {
      let _in;                    /* local strm.input */
      let last;                   /* have enough input while in < last */
      let _out;                   /* local strm.output */
      let beg;                    /* inflate()'s initial strm.output */
      let end;                    /* while out < end, enough space available */
    //#ifdef INFLATE_STRICT
      let dmax;                   /* maximum distance from zlib header */
    //#endif
      let wsize;                  /* window size or zero if not using window */
      let whave;                  /* valid bytes in the window */
      let wnext;                  /* window write index */
      // Use `s_window` instead `window`, avoid conflict with instrumentation tools
      let s_window;               /* allocated sliding window, if wsize != 0 */
      let hold;                   /* local strm.hold */
      let bits;                   /* local strm.bits */
      let lcode;                  /* local strm.lencode */
      let dcode;                  /* local strm.distcode */
      let lmask;                  /* mask for first level of length codes */
      let dmask;                  /* mask for first level of distance codes */
      let here;                   /* retrieved table entry */
      let op;                     /* code bits, operation, extra bits, or */
                                  /*  window position, window bytes to copy */
      let len;                    /* match length, unused bytes */
      let dist;                   /* match distance */
      let from;                   /* where to copy match from */
      let from_source;


      let input, output; // JS specific, because we have no pointers

      /* copy state to local variables */
      const state = strm.state;
      //here = state.here;
      _in = strm.next_in;
      input = strm.input;
      last = _in + (strm.avail_in - 5);
      _out = strm.next_out;
      output = strm.output;
      beg = _out - (start - strm.avail_out);
      end = _out + (strm.avail_out - 257);
    //#ifdef INFLATE_STRICT
      dmax = state.dmax;
    //#endif
      wsize = state.wsize;
      whave = state.whave;
      wnext = state.wnext;
      s_window = state.window;
      hold = state.hold;
      bits = state.bits;
      lcode = state.lencode;
      dcode = state.distcode;
      lmask = (1 << state.lenbits) - 1;
      dmask = (1 << state.distbits) - 1;


      /* decode literals and length/distances until end-of-block or not enough
         input data or output space */

      top:
      do {
        if (bits < 15) {
          hold += input[_in++] << bits;
          bits += 8;
          hold += input[_in++] << bits;
          bits += 8;
        }

        here = lcode[hold & lmask];

        dolen:
        for (;;) { // Goto emulation
          op = here >>> 24/*here.bits*/;
          hold >>>= op;
          bits -= op;
          op = (here >>> 16) & 0xff/*here.op*/;
          if (op === 0) {                          /* literal */
            //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
            //        "inflate:         literal '%c'\n" :
            //        "inflate:         literal 0x%02x\n", here.val));
            output[_out++] = here & 0xffff/*here.val*/;
          }
          else if (op & 16) {                     /* length base */
            len = here & 0xffff/*here.val*/;
            op &= 15;                           /* number of extra bits */
            if (op) {
              if (bits < op) {
                hold += input[_in++] << bits;
                bits += 8;
              }
              len += hold & ((1 << op) - 1);
              hold >>>= op;
              bits -= op;
            }
            //Tracevv((stderr, "inflate:         length %u\n", len));
            if (bits < 15) {
              hold += input[_in++] << bits;
              bits += 8;
              hold += input[_in++] << bits;
              bits += 8;
            }
            here = dcode[hold & dmask];

            dodist:
            for (;;) { // goto emulation
              op = here >>> 24/*here.bits*/;
              hold >>>= op;
              bits -= op;
              op = (here >>> 16) & 0xff/*here.op*/;

              if (op & 16) {                      /* distance base */
                dist = here & 0xffff/*here.val*/;
                op &= 15;                       /* number of extra bits */
                if (bits < op) {
                  hold += input[_in++] << bits;
                  bits += 8;
                  if (bits < op) {
                    hold += input[_in++] << bits;
                    bits += 8;
                  }
                }
                dist += hold & ((1 << op) - 1);
    //#ifdef INFLATE_STRICT
                if (dist > dmax) {
                  strm.msg = 'invalid distance too far back';
                  state.mode = BAD;
                  break top;
                }
    //#endif
                hold >>>= op;
                bits -= op;
                //Tracevv((stderr, "inflate:         distance %u\n", dist));
                op = _out - beg;                /* max distance in output */
                if (dist > op) {                /* see if copy from window */
                  op = dist - op;               /* distance back in window */
                  if (op > whave) {
                    if (state.sane) {
                      strm.msg = 'invalid distance too far back';
                      state.mode = BAD;
                      break top;
                    }

    // (!) This block is disabled in zlib defaults,
    // don't enable it for binary compatibility
    //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
    //                if (len <= op - whave) {
    //                  do {
    //                    output[_out++] = 0;
    //                  } while (--len);
    //                  continue top;
    //                }
    //                len -= op - whave;
    //                do {
    //                  output[_out++] = 0;
    //                } while (--op > whave);
    //                if (op === 0) {
    //                  from = _out - dist;
    //                  do {
    //                    output[_out++] = output[from++];
    //                  } while (--len);
    //                  continue top;
    //                }
    //#endif
                  }
                  from = 0; // window index
                  from_source = s_window;
                  if (wnext === 0) {           /* very common case */
                    from += wsize - op;
                    if (op < len) {         /* some from window */
                      len -= op;
                      do {
                        output[_out++] = s_window[from++];
                      } while (--op);
                      from = _out - dist;  /* rest from output */
                      from_source = output;
                    }
                  }
                  else if (wnext < op) {      /* wrap around window */
                    from += wsize + wnext - op;
                    op -= wnext;
                    if (op < len) {         /* some from end of window */
                      len -= op;
                      do {
                        output[_out++] = s_window[from++];
                      } while (--op);
                      from = 0;
                      if (wnext < len) {  /* some from start of window */
                        op = wnext;
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = _out - dist;      /* rest from output */
                        from_source = output;
                      }
                    }
                  }
                  else {                      /* contiguous in window */
                    from += wnext - op;
                    if (op < len) {         /* some from window */
                      len -= op;
                      do {
                        output[_out++] = s_window[from++];
                      } while (--op);
                      from = _out - dist;  /* rest from output */
                      from_source = output;
                    }
                  }
                  while (len > 2) {
                    output[_out++] = from_source[from++];
                    output[_out++] = from_source[from++];
                    output[_out++] = from_source[from++];
                    len -= 3;
                  }
                  if (len) {
                    output[_out++] = from_source[from++];
                    if (len > 1) {
                      output[_out++] = from_source[from++];
                    }
                  }
                }
                else {
                  from = _out - dist;          /* copy direct from output */
                  do {                        /* minimum length is three */
                    output[_out++] = output[from++];
                    output[_out++] = output[from++];
                    output[_out++] = output[from++];
                    len -= 3;
                  } while (len > 2);
                  if (len) {
                    output[_out++] = output[from++];
                    if (len > 1) {
                      output[_out++] = output[from++];
                    }
                  }
                }
              }
              else if ((op & 64) === 0) {          /* 2nd level distance code */
                here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
                continue dodist;
              }
              else {
                strm.msg = 'invalid distance code';
                state.mode = BAD;
                break top;
              }

              break; // need to emulate goto via "continue"
            }
          }
          else if ((op & 64) === 0) {              /* 2nd level length code */
            here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
            continue dolen;
          }
          else if (op & 32) {                     /* end-of-block */
            //Tracevv((stderr, "inflate:         end of block\n"));
            state.mode = TYPE;
            break top;
          }
          else {
            strm.msg = 'invalid literal/length code';
            state.mode = BAD;
            break top;
          }

          break; // need to emulate goto via "continue"
        }
      } while (_in < last && _out < end);

      /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
      len = bits >> 3;
      _in -= len;
      bits -= len << 3;
      hold &= (1 << bits) - 1;

      /* update state and return */
      strm.next_in = _in;
      strm.next_out = _out;
      strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
      strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
      state.hold = hold;
      state.bits = bits;
      return;
    };

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    const MAXBITS = 15;
    const ENOUGH_LENS = 852;
    const ENOUGH_DISTS = 592;
    //const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);

    const CODES = 0;
    const LENS = 1;
    const DISTS = 2;

    const lbase = new Uint16Array([ /* Length codes 257..285 base */
      3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
      35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
    ]);

    const lext = new Uint8Array([ /* Length codes 257..285 extra */
      16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
      19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
    ]);

    const dbase = new Uint16Array([ /* Distance codes 0..29 base */
      1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
      257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
      8193, 12289, 16385, 24577, 0, 0
    ]);

    const dext = new Uint8Array([ /* Distance codes 0..29 extra */
      16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
      23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
      28, 28, 29, 29, 64, 64
    ]);

    const inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) =>
    {
      const bits = opts.bits;
          //here = opts.here; /* table entry for duplication */

      let len = 0;               /* a code's length in bits */
      let sym = 0;               /* index of code symbols */
      let min = 0, max = 0;          /* minimum and maximum code lengths */
      let root = 0;              /* number of index bits for root table */
      let curr = 0;              /* number of index bits for current table */
      let drop = 0;              /* code bits to drop for sub-table */
      let left = 0;                   /* number of prefix codes available */
      let used = 0;              /* code entries in table used */
      let huff = 0;              /* Huffman code */
      let incr;              /* for incrementing code, index */
      let fill;              /* index for replicating entries */
      let low;               /* low bits for current root entry */
      let mask;              /* mask for low root bits */
      let next;             /* next available space in table */
      let base = null;     /* base value table to use */
      let base_index = 0;
    //  let shoextra;    /* extra bits table to use */
      let end;                    /* use base and extra for symbol > end */
      const count = new Uint16Array(MAXBITS + 1); //[MAXBITS+1];    /* number of codes of each length */
      const offs = new Uint16Array(MAXBITS + 1); //[MAXBITS+1];     /* offsets in table for each length */
      let extra = null;
      let extra_index = 0;

      let here_bits, here_op, here_val;

      /*
       Process a set of code lengths to create a canonical Huffman code.  The
       code lengths are lens[0..codes-1].  Each length corresponds to the
       symbols 0..codes-1.  The Huffman code is generated by first sorting the
       symbols by length from short to long, and retaining the symbol order
       for codes with equal lengths.  Then the code starts with all zero bits
       for the first code of the shortest length, and the codes are integer
       increments for the same length, and zeros are appended as the length
       increases.  For the deflate format, these bits are stored backwards
       from their more natural integer increment ordering, and so when the
       decoding tables are built in the large loop below, the integer codes
       are incremented backwards.

       This routine assumes, but does not check, that all of the entries in
       lens[] are in the range 0..MAXBITS.  The caller must assure this.
       1..MAXBITS is interpreted as that code length.  zero means that that
       symbol does not occur in this code.

       The codes are sorted by computing a count of codes for each length,
       creating from that a table of starting indices for each length in the
       sorted table, and then entering the symbols in order in the sorted
       table.  The sorted table is work[], with that space being provided by
       the caller.

       The length counts are used for other purposes as well, i.e. finding
       the minimum and maximum length codes, determining if there are any
       codes at all, checking for a valid set of lengths, and looking ahead
       at length counts to determine sub-table sizes when building the
       decoding tables.
       */

      /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
      for (len = 0; len <= MAXBITS; len++) {
        count[len] = 0;
      }
      for (sym = 0; sym < codes; sym++) {
        count[lens[lens_index + sym]]++;
      }

      /* bound code lengths, force root to be within code lengths */
      root = bits;
      for (max = MAXBITS; max >= 1; max--) {
        if (count[max] !== 0) { break; }
      }
      if (root > max) {
        root = max;
      }
      if (max === 0) {                     /* no symbols to code at all */
        //table.op[opts.table_index] = 64;  //here.op = (var char)64;    /* invalid code marker */
        //table.bits[opts.table_index] = 1;   //here.bits = (var char)1;
        //table.val[opts.table_index++] = 0;   //here.val = (var short)0;
        table[table_index++] = (1 << 24) | (64 << 16) | 0;


        //table.op[opts.table_index] = 64;
        //table.bits[opts.table_index] = 1;
        //table.val[opts.table_index++] = 0;
        table[table_index++] = (1 << 24) | (64 << 16) | 0;

        opts.bits = 1;
        return 0;     /* no symbols, but wait for decoding to report error */
      }
      for (min = 1; min < max; min++) {
        if (count[min] !== 0) { break; }
      }
      if (root < min) {
        root = min;
      }

      /* check for an over-subscribed or incomplete set of lengths */
      left = 1;
      for (len = 1; len <= MAXBITS; len++) {
        left <<= 1;
        left -= count[len];
        if (left < 0) {
          return -1;
        }        /* over-subscribed */
      }
      if (left > 0 && (type === CODES || max !== 1)) {
        return -1;                      /* incomplete set */
      }

      /* generate offsets into symbol table for each length for sorting */
      offs[1] = 0;
      for (len = 1; len < MAXBITS; len++) {
        offs[len + 1] = offs[len] + count[len];
      }

      /* sort symbols by length, by symbol order within each length */
      for (sym = 0; sym < codes; sym++) {
        if (lens[lens_index + sym] !== 0) {
          work[offs[lens[lens_index + sym]]++] = sym;
        }
      }

      /*
       Create and fill in decoding tables.  In this loop, the table being
       filled is at next and has curr index bits.  The code being used is huff
       with length len.  That code is converted to an index by dropping drop
       bits off of the bottom.  For codes where len is less than drop + curr,
       those top drop + curr - len bits are incremented through all values to
       fill the table with replicated entries.

       root is the number of index bits for the root table.  When len exceeds
       root, sub-tables are created pointed to by the root entry with an index
       of the low root bits of huff.  This is saved in low to check for when a
       new sub-table should be started.  drop is zero when the root table is
       being filled, and drop is root when sub-tables are being filled.

       When a new sub-table is needed, it is necessary to look ahead in the
       code lengths to determine what size sub-table is needed.  The length
       counts are used for this, and so count[] is decremented as codes are
       entered in the tables.

       used keeps track of how many table entries have been allocated from the
       provided *table space.  It is checked for LENS and DIST tables against
       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
       the initial root table size constants.  See the comments in inftrees.h
       for more information.

       sym increments through all symbols, and the loop terminates when
       all codes of length max, i.e. all codes, have been processed.  This
       routine permits incomplete codes, so another loop after this one fills
       in the rest of the decoding tables with invalid code markers.
       */

      /* set up for code type */
      // poor man optimization - use if-else instead of switch,
      // to avoid deopts in old v8
      if (type === CODES) {
        base = extra = work;    /* dummy value--not used */
        end = 19;

      } else if (type === LENS) {
        base = lbase;
        base_index -= 257;
        extra = lext;
        extra_index -= 257;
        end = 256;

      } else {                    /* DISTS */
        base = dbase;
        extra = dext;
        end = -1;
      }

      /* initialize opts for loop */
      huff = 0;                   /* starting code */
      sym = 0;                    /* starting code symbol */
      len = min;                  /* starting code length */
      next = table_index;              /* current table to fill in */
      curr = root;                /* current table index bits */
      drop = 0;                   /* current bits to drop from code for index */
      low = -1;                   /* trigger new sub-table when len > root */
      used = 1 << root;          /* use root table entries */
      mask = used - 1;            /* mask for comparing low */

      /* check available table space */
      if ((type === LENS && used > ENOUGH_LENS) ||
        (type === DISTS && used > ENOUGH_DISTS)) {
        return 1;
      }

      /* process all codes and make table entries */
      for (;;) {
        /* create table entry */
        here_bits = len - drop;
        if (work[sym] < end) {
          here_op = 0;
          here_val = work[sym];
        }
        else if (work[sym] > end) {
          here_op = extra[extra_index + work[sym]];
          here_val = base[base_index + work[sym]];
        }
        else {
          here_op = 32 + 64;         /* end of block */
          here_val = 0;
        }

        /* replicate for those indices with low len bits equal to huff */
        incr = 1 << (len - drop);
        fill = 1 << curr;
        min = fill;                 /* save offset to next table */
        do {
          fill -= incr;
          table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
        } while (fill !== 0);

        /* backwards increment the len-bit code huff */
        incr = 1 << (len - 1);
        while (huff & incr) {
          incr >>= 1;
        }
        if (incr !== 0) {
          huff &= incr - 1;
          huff += incr;
        } else {
          huff = 0;
        }

        /* go to next symbol, update count, len */
        sym++;
        if (--count[len] === 0) {
          if (len === max) { break; }
          len = lens[lens_index + work[sym]];
        }

        /* create new sub-table if needed */
        if (len > root && (huff & mask) !== low) {
          /* if first time, transition to sub-tables */
          if (drop === 0) {
            drop = root;
          }

          /* increment past last table */
          next += min;            /* here min is 1 << curr */

          /* determine length of next table */
          curr = len - drop;
          left = 1 << curr;
          while (curr + drop < max) {
            left -= count[curr + drop];
            if (left <= 0) { break; }
            curr++;
            left <<= 1;
          }

          /* check for enough space */
          used += 1 << curr;
          if ((type === LENS && used > ENOUGH_LENS) ||
            (type === DISTS && used > ENOUGH_DISTS)) {
            return 1;
          }

          /* point entry in root table to sub-table */
          low = huff & mask;
          /*table.op[low] = curr;
          table.bits[low] = root;
          table.val[low] = next - opts.table_index;*/
          table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
        }
      }

      /* fill in remaining table entry if code is incomplete (guaranteed to have
       at most one remaining entry, since if the code is incomplete, the
       maximum code length that was allowed to get this far is one bit) */
      if (huff !== 0) {
        //table.op[next + huff] = 64;            /* invalid code marker */
        //table.bits[next + huff] = len - drop;
        //table.val[next + huff] = 0;
        table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
      }

      /* set return parameters */
      //opts.table_index += used;
      opts.bits = root;
      return 0;
    };


    var inftrees = inflate_table;

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.






    const CODES$1 = 0;
    const LENS$1 = 1;
    const DISTS$1 = 2;

    /* Public constants ==========================================================*/
    /* ===========================================================================*/

    const {
      Z_FINISH: Z_FINISH$2, Z_BLOCK: Z_BLOCK$1, Z_TREES,
      Z_OK: Z_OK$2, Z_STREAM_END: Z_STREAM_END$2, Z_NEED_DICT, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR, Z_BUF_ERROR: Z_BUF_ERROR$1,
      Z_DEFLATED: Z_DEFLATED$2
    } = constants;


    /* STATES ====================================================================*/
    /* ===========================================================================*/


    const    HEAD = 1;       /* i: waiting for magic header */
    const    FLAGS = 2;      /* i: waiting for method and flags (gzip) */
    const    TIME = 3;       /* i: waiting for modification time (gzip) */
    const    OS = 4;         /* i: waiting for extra flags and operating system (gzip) */
    const    EXLEN = 5;      /* i: waiting for extra length (gzip) */
    const    EXTRA = 6;      /* i: waiting for extra bytes (gzip) */
    const    NAME = 7;       /* i: waiting for end of file name (gzip) */
    const    COMMENT = 8;    /* i: waiting for end of comment (gzip) */
    const    HCRC = 9;       /* i: waiting for header crc (gzip) */
    const    DICTID = 10;    /* i: waiting for dictionary check value */
    const    DICT = 11;      /* waiting for inflateSetDictionary() call */
    const        TYPE$1 = 12;      /* i: waiting for type bits, including last-flag bit */
    const        TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */
    const        STORED = 14;    /* i: waiting for stored size (length and complement) */
    const        COPY_ = 15;     /* i/o: same as COPY below, but only first time in */
    const        COPY = 16;      /* i/o: waiting for input or output to copy stored block */
    const        TABLE = 17;     /* i: waiting for dynamic block table lengths */
    const        LENLENS = 18;   /* i: waiting for code length code lengths */
    const        CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */
    const            LEN_ = 20;      /* i: same as LEN below, but only first time in */
    const            LEN = 21;       /* i: waiting for length/lit/eob code */
    const            LENEXT = 22;    /* i: waiting for length extra bits */
    const            DIST = 23;      /* i: waiting for distance code */
    const            DISTEXT = 24;   /* i: waiting for distance extra bits */
    const            MATCH = 25;     /* o: waiting for output space to copy string */
    const            LIT = 26;       /* o: waiting for output space to write literal */
    const    CHECK = 27;     /* i: waiting for 32-bit check value */
    const    LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */
    const    DONE = 29;      /* finished check, done -- remain here until reset */
    const    BAD$1 = 30;       /* got a data error -- remain here until reset */
    const    MEM = 31;       /* got an inflate() memory error -- remain here until reset */
    const    SYNC = 32;      /* looking for synchronization bytes to restart inflate() */

    /* ===========================================================================*/



    const ENOUGH_LENS$1 = 852;
    const ENOUGH_DISTS$1 = 592;
    //const ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);

    const MAX_WBITS$1 = 15;
    /* 32K LZ77 window */
    const DEF_WBITS = MAX_WBITS$1;


    const zswap32 = (q) => {

      return  (((q >>> 24) & 0xff) +
              ((q >>> 8) & 0xff00) +
              ((q & 0xff00) << 8) +
              ((q & 0xff) << 24));
    };


    function InflateState() {
      this.mode = 0;             /* current inflate mode */
      this.last = false;          /* true if processing last block */
      this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
      this.havedict = false;      /* true if dictionary provided */
      this.flags = 0;             /* gzip header method and flags (0 if zlib) */
      this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */
      this.check = 0;             /* protected copy of check value */
      this.total = 0;             /* protected copy of output count */
      // TODO: may be {}
      this.head = null;           /* where to save gzip header information */

      /* sliding window */
      this.wbits = 0;             /* log base 2 of requested window size */
      this.wsize = 0;             /* window size or zero if not using window */
      this.whave = 0;             /* valid bytes in the window */
      this.wnext = 0;             /* window write index */
      this.window = null;         /* allocated sliding window, if needed */

      /* bit accumulator */
      this.hold = 0;              /* input bit accumulator */
      this.bits = 0;              /* number of bits in "in" */

      /* for string and stored block copying */
      this.length = 0;            /* literal or length of data to copy */
      this.offset = 0;            /* distance back to copy string from */

      /* for table and code decoding */
      this.extra = 0;             /* extra bits needed */

      /* fixed and dynamic code tables */
      this.lencode = null;          /* starting table for length/literal codes */
      this.distcode = null;         /* starting table for distance codes */
      this.lenbits = 0;           /* index bits for lencode */
      this.distbits = 0;          /* index bits for distcode */

      /* dynamic table building */
      this.ncode = 0;             /* number of code length code lengths */
      this.nlen = 0;              /* number of length code lengths */
      this.ndist = 0;             /* number of distance code lengths */
      this.have = 0;              /* number of code lengths in lens[] */
      this.next = null;              /* next available space in codes[] */

      this.lens = new Uint16Array(320); /* temporary storage for code lengths */
      this.work = new Uint16Array(288); /* work area for code table building */

      /*
       because we don't have pointers in js, we use lencode and distcode directly
       as buffers so we don't need codes
      */
      //this.codes = new Int32Array(ENOUGH);       /* space for code tables */
      this.lendyn = null;              /* dynamic table for length/literal codes (JS specific) */
      this.distdyn = null;             /* dynamic table for distance codes (JS specific) */
      this.sane = 0;                   /* if false, allow invalid distance too far */
      this.back = 0;                   /* bits back of last unprocessed length/lit */
      this.was = 0;                    /* initial length of match */
    }


    const inflateResetKeep = (strm) => {

      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
      const state = strm.state;
      strm.total_in = strm.total_out = state.total = 0;
      strm.msg = ''; /*Z_NULL*/
      if (state.wrap) {       /* to support ill-conceived Java test suite */
        strm.adler = state.wrap & 1;
      }
      state.mode = HEAD;
      state.last = 0;
      state.havedict = 0;
      state.dmax = 32768;
      state.head = null/*Z_NULL*/;
      state.hold = 0;
      state.bits = 0;
      //state.lencode = state.distcode = state.next = state.codes;
      state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS$1);
      state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS$1);

      state.sane = 1;
      state.back = -1;
      //Tracev((stderr, "inflate: reset\n"));
      return Z_OK$2;
    };


    const inflateReset = (strm) => {

      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
      const state = strm.state;
      state.wsize = 0;
      state.whave = 0;
      state.wnext = 0;
      return inflateResetKeep(strm);

    };


    const inflateReset2 = (strm, windowBits) => {
      let wrap;

      /* get the state */
      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
      const state = strm.state;

      /* extract wrap request from windowBits parameter */
      if (windowBits < 0) {
        wrap = 0;
        windowBits = -windowBits;
      }
      else {
        wrap = (windowBits >> 4) + 1;
        if (windowBits < 48) {
          windowBits &= 15;
        }
      }

      /* set number of window bits, free window if different */
      if (windowBits && (windowBits < 8 || windowBits > 15)) {
        return Z_STREAM_ERROR$1;
      }
      if (state.window !== null && state.wbits !== windowBits) {
        state.window = null;
      }

      /* update state and reset the rest of it */
      state.wrap = wrap;
      state.wbits = windowBits;
      return inflateReset(strm);
    };


    const inflateInit2 = (strm, windowBits) => {

      if (!strm) { return Z_STREAM_ERROR$1; }
      //strm.msg = Z_NULL;                 /* in case we return an error */

      const state = new InflateState();

      //if (state === Z_NULL) return Z_MEM_ERROR;
      //Tracev((stderr, "inflate: allocated\n"));
      strm.state = state;
      state.window = null/*Z_NULL*/;
      const ret = inflateReset2(strm, windowBits);
      if (ret !== Z_OK$2) {
        strm.state = null/*Z_NULL*/;
      }
      return ret;
    };


    const inflateInit = (strm) => {

      return inflateInit2(strm, DEF_WBITS);
    };


    /*
     Return state with length and distance decoding tables and index sizes set to
     fixed code decoding.  Normally this returns fixed tables from inffixed.h.
     If BUILDFIXED is defined, then instead this routine builds the tables the
     first time it's called, and returns those tables the first time and
     thereafter.  This reduces the size of the code by about 2K bytes, in
     exchange for a little execution time.  However, BUILDFIXED should not be
     used for threaded applications, since the rewriting of the tables and virgin
     may not be thread-safe.
     */
    let virgin = true;

    let lenfix, distfix; // We have no pointers in JS, so keep tables separate


    const fixedtables = (state) => {

      /* build fixed huffman tables if first call (may not be thread safe) */
      if (virgin) {
        lenfix = new Int32Array(512);
        distfix = new Int32Array(32);

        /* literal/length table */
        let sym = 0;
        while (sym < 144) { state.lens[sym++] = 8; }
        while (sym < 256) { state.lens[sym++] = 9; }
        while (sym < 280) { state.lens[sym++] = 7; }
        while (sym < 288) { state.lens[sym++] = 8; }

        inftrees(LENS$1,  state.lens, 0, 288, lenfix,   0, state.work, { bits: 9 });

        /* distance table */
        sym = 0;
        while (sym < 32) { state.lens[sym++] = 5; }

        inftrees(DISTS$1, state.lens, 0, 32,   distfix, 0, state.work, { bits: 5 });

        /* do this just once */
        virgin = false;
      }

      state.lencode = lenfix;
      state.lenbits = 9;
      state.distcode = distfix;
      state.distbits = 5;
    };


    /*
     Update the window with the last wsize (normally 32K) bytes written before
     returning.  If window does not exist yet, create it.  This is only called
     when a window is already in use, or when output has been written during this
     inflate call, but the end of the deflate stream has not been reached yet.
     It is also called to create a window for dictionary data when a dictionary
     is loaded.

     Providing output buffers larger than 32K to inflate() should provide a speed
     advantage, since only the last 32K of output is copied to the sliding window
     upon return from inflate(), and since all distances after the first 32K of
     output will fall in the output data, making match copies simpler and faster.
     The advantage may be dependent on the size of the processor's data caches.
     */
    const updatewindow = (strm, src, end, copy) => {

      let dist;
      const state = strm.state;

      /* if it hasn't been done already, allocate space for the window */
      if (state.window === null) {
        state.wsize = 1 << state.wbits;
        state.wnext = 0;
        state.whave = 0;

        state.window = new Uint8Array(state.wsize);
      }

      /* copy state->wsize or less output bytes into the circular window */
      if (copy >= state.wsize) {
        state.window.set(src.subarray(end - state.wsize, end), 0);
        state.wnext = 0;
        state.whave = state.wsize;
      }
      else {
        dist = state.wsize - state.wnext;
        if (dist > copy) {
          dist = copy;
        }
        //zmemcpy(state->window + state->wnext, end - copy, dist);
        state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);
        copy -= dist;
        if (copy) {
          //zmemcpy(state->window, end - copy, copy);
          state.window.set(src.subarray(end - copy, end), 0);
          state.wnext = copy;
          state.whave = state.wsize;
        }
        else {
          state.wnext += dist;
          if (state.wnext === state.wsize) { state.wnext = 0; }
          if (state.whave < state.wsize) { state.whave += dist; }
        }
      }
      return 0;
    };


    const inflate = (strm, flush) => {

      let state;
      let input, output;          // input/output buffers
      let next;                   /* next input INDEX */
      let put;                    /* next output INDEX */
      let have, left;             /* available input and output */
      let hold;                   /* bit buffer */
      let bits;                   /* bits in bit buffer */
      let _in, _out;              /* save starting available input and output */
      let copy;                   /* number of stored or match bytes to copy */
      let from;                   /* where to copy match bytes from */
      let from_source;
      let here = 0;               /* current decoding table entry */
      let here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
      //let last;                   /* parent table entry */
      let last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
      let len;                    /* length to copy for repeats, bits to drop */
      let ret;                    /* return code */
      const hbuf = new Uint8Array(4);    /* buffer for gzip header crc calculation */
      let opts;

      let n; // temporary variable for NEED_BITS

      const order = /* permutation of code lengths */
        new Uint8Array([ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]);


      if (!strm || !strm.state || !strm.output ||
          (!strm.input && strm.avail_in !== 0)) {
        return Z_STREAM_ERROR$1;
      }

      state = strm.state;
      if (state.mode === TYPE$1) { state.mode = TYPEDO; }    /* skip check */


      //--- LOAD() ---
      put = strm.next_out;
      output = strm.output;
      left = strm.avail_out;
      next = strm.next_in;
      input = strm.input;
      have = strm.avail_in;
      hold = state.hold;
      bits = state.bits;
      //---

      _in = have;
      _out = left;
      ret = Z_OK$2;

      inf_leave: // goto emulation
      for (;;) {
        switch (state.mode) {
          case HEAD:
            if (state.wrap === 0) {
              state.mode = TYPEDO;
              break;
            }
            //=== NEEDBITS(16);
            while (bits < 16) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            if ((state.wrap & 2) && hold === 0x8b1f) {  /* gzip header */
              state.check = 0/*crc32(0L, Z_NULL, 0)*/;
              //=== CRC2(state.check, hold);
              hbuf[0] = hold & 0xff;
              hbuf[1] = (hold >>> 8) & 0xff;
              state.check = crc32_1(state.check, hbuf, 2, 0);
              //===//

              //=== INITBITS();
              hold = 0;
              bits = 0;
              //===//
              state.mode = FLAGS;
              break;
            }
            state.flags = 0;           /* expect zlib header */
            if (state.head) {
              state.head.done = false;
            }
            if (!(state.wrap & 1) ||   /* check if zlib header allowed */
              (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
              strm.msg = 'incorrect header check';
              state.mode = BAD$1;
              break;
            }
            if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED$2) {
              strm.msg = 'unknown compression method';
              state.mode = BAD$1;
              break;
            }
            //--- DROPBITS(4) ---//
            hold >>>= 4;
            bits -= 4;
            //---//
            len = (hold & 0x0f)/*BITS(4)*/ + 8;
            if (state.wbits === 0) {
              state.wbits = len;
            }
            else if (len > state.wbits) {
              strm.msg = 'invalid window size';
              state.mode = BAD$1;
              break;
            }

            // !!! pako patch. Force use `options.windowBits` if passed.
            // Required to always use max window size by default.
            state.dmax = 1 << state.wbits;
            //state.dmax = 1 << len;

            //Tracev((stderr, "inflate:   zlib header ok\n"));
            strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
            state.mode = hold & 0x200 ? DICTID : TYPE$1;
            //=== INITBITS();
            hold = 0;
            bits = 0;
            //===//
            break;
          case FLAGS:
            //=== NEEDBITS(16); */
            while (bits < 16) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            state.flags = hold;
            if ((state.flags & 0xff) !== Z_DEFLATED$2) {
              strm.msg = 'unknown compression method';
              state.mode = BAD$1;
              break;
            }
            if (state.flags & 0xe000) {
              strm.msg = 'unknown header flags set';
              state.mode = BAD$1;
              break;
            }
            if (state.head) {
              state.head.text = ((hold >> 8) & 1);
            }
            if (state.flags & 0x0200) {
              //=== CRC2(state.check, hold);
              hbuf[0] = hold & 0xff;
              hbuf[1] = (hold >>> 8) & 0xff;
              state.check = crc32_1(state.check, hbuf, 2, 0);
              //===//
            }
            //=== INITBITS();
            hold = 0;
            bits = 0;
            //===//
            state.mode = TIME;
            /* falls through */
          case TIME:
            //=== NEEDBITS(32); */
            while (bits < 32) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            if (state.head) {
              state.head.time = hold;
            }
            if (state.flags & 0x0200) {
              //=== CRC4(state.check, hold)
              hbuf[0] = hold & 0xff;
              hbuf[1] = (hold >>> 8) & 0xff;
              hbuf[2] = (hold >>> 16) & 0xff;
              hbuf[3] = (hold >>> 24) & 0xff;
              state.check = crc32_1(state.check, hbuf, 4, 0);
              //===
            }
            //=== INITBITS();
            hold = 0;
            bits = 0;
            //===//
            state.mode = OS;
            /* falls through */
          case OS:
            //=== NEEDBITS(16); */
            while (bits < 16) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            if (state.head) {
              state.head.xflags = (hold & 0xff);
              state.head.os = (hold >> 8);
            }
            if (state.flags & 0x0200) {
              //=== CRC2(state.check, hold);
              hbuf[0] = hold & 0xff;
              hbuf[1] = (hold >>> 8) & 0xff;
              state.check = crc32_1(state.check, hbuf, 2, 0);
              //===//
            }
            //=== INITBITS();
            hold = 0;
            bits = 0;
            //===//
            state.mode = EXLEN;
            /* falls through */
          case EXLEN:
            if (state.flags & 0x0400) {
              //=== NEEDBITS(16); */
              while (bits < 16) {
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
              }
              //===//
              state.length = hold;
              if (state.head) {
                state.head.extra_len = hold;
              }
              if (state.flags & 0x0200) {
                //=== CRC2(state.check, hold);
                hbuf[0] = hold & 0xff;
                hbuf[1] = (hold >>> 8) & 0xff;
                state.check = crc32_1(state.check, hbuf, 2, 0);
                //===//
              }
              //=== INITBITS();
              hold = 0;
              bits = 0;
              //===//
            }
            else if (state.head) {
              state.head.extra = null/*Z_NULL*/;
            }
            state.mode = EXTRA;
            /* falls through */
          case EXTRA:
            if (state.flags & 0x0400) {
              copy = state.length;
              if (copy > have) { copy = have; }
              if (copy) {
                if (state.head) {
                  len = state.head.extra_len - state.length;
                  if (!state.head.extra) {
                    // Use untyped array for more convenient processing later
                    state.head.extra = new Uint8Array(state.head.extra_len);
                  }
                  state.head.extra.set(
                    input.subarray(
                      next,
                      // extra field is limited to 65536 bytes
                      // - no need for additional size check
                      next + copy
                    ),
                    /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                    len
                  );
                  //zmemcpy(state.head.extra + len, next,
                  //        len + copy > state.head.extra_max ?
                  //        state.head.extra_max - len : copy);
                }
                if (state.flags & 0x0200) {
                  state.check = crc32_1(state.check, input, copy, next);
                }
                have -= copy;
                next += copy;
                state.length -= copy;
              }
              if (state.length) { break inf_leave; }
            }
            state.length = 0;
            state.mode = NAME;
            /* falls through */
          case NAME:
            if (state.flags & 0x0800) {
              if (have === 0) { break inf_leave; }
              copy = 0;
              do {
                // TODO: 2 or 1 bytes?
                len = input[next + copy++];
                /* use constant limit because in js we should not preallocate memory */
                if (state.head && len &&
                    (state.length < 65536 /*state.head.name_max*/)) {
                  state.head.name += String.fromCharCode(len);
                }
              } while (len && copy < have);

              if (state.flags & 0x0200) {
                state.check = crc32_1(state.check, input, copy, next);
              }
              have -= copy;
              next += copy;
              if (len) { break inf_leave; }
            }
            else if (state.head) {
              state.head.name = null;
            }
            state.length = 0;
            state.mode = COMMENT;
            /* falls through */
          case COMMENT:
            if (state.flags & 0x1000) {
              if (have === 0) { break inf_leave; }
              copy = 0;
              do {
                len = input[next + copy++];
                /* use constant limit because in js we should not preallocate memory */
                if (state.head && len &&
                    (state.length < 65536 /*state.head.comm_max*/)) {
                  state.head.comment += String.fromCharCode(len);
                }
              } while (len && copy < have);
              if (state.flags & 0x0200) {
                state.check = crc32_1(state.check, input, copy, next);
              }
              have -= copy;
              next += copy;
              if (len) { break inf_leave; }
            }
            else if (state.head) {
              state.head.comment = null;
            }
            state.mode = HCRC;
            /* falls through */
          case HCRC:
            if (state.flags & 0x0200) {
              //=== NEEDBITS(16); */
              while (bits < 16) {
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
              }
              //===//
              if (hold !== (state.check & 0xffff)) {
                strm.msg = 'header crc mismatch';
                state.mode = BAD$1;
                break;
              }
              //=== INITBITS();
              hold = 0;
              bits = 0;
              //===//
            }
            if (state.head) {
              state.head.hcrc = ((state.flags >> 9) & 1);
              state.head.done = true;
            }
            strm.adler = state.check = 0;
            state.mode = TYPE$1;
            break;
          case DICTID:
            //=== NEEDBITS(32); */
            while (bits < 32) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            strm.adler = state.check = zswap32(hold);
            //=== INITBITS();
            hold = 0;
            bits = 0;
            //===//
            state.mode = DICT;
            /* falls through */
          case DICT:
            if (state.havedict === 0) {
              //--- RESTORE() ---
              strm.next_out = put;
              strm.avail_out = left;
              strm.next_in = next;
              strm.avail_in = have;
              state.hold = hold;
              state.bits = bits;
              //---
              return Z_NEED_DICT;
            }
            strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
            state.mode = TYPE$1;
            /* falls through */
          case TYPE$1:
            if (flush === Z_BLOCK$1 || flush === Z_TREES) { break inf_leave; }
            /* falls through */
          case TYPEDO:
            if (state.last) {
              //--- BYTEBITS() ---//
              hold >>>= bits & 7;
              bits -= bits & 7;
              //---//
              state.mode = CHECK;
              break;
            }
            //=== NEEDBITS(3); */
            while (bits < 3) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            state.last = (hold & 0x01)/*BITS(1)*/;
            //--- DROPBITS(1) ---//
            hold >>>= 1;
            bits -= 1;
            //---//

            switch ((hold & 0x03)/*BITS(2)*/) {
              case 0:                             /* stored block */
                //Tracev((stderr, "inflate:     stored block%s\n",
                //        state.last ? " (last)" : ""));
                state.mode = STORED;
                break;
              case 1:                             /* fixed block */
                fixedtables(state);
                //Tracev((stderr, "inflate:     fixed codes block%s\n",
                //        state.last ? " (last)" : ""));
                state.mode = LEN_;             /* decode codes */
                if (flush === Z_TREES) {
                  //--- DROPBITS(2) ---//
                  hold >>>= 2;
                  bits -= 2;
                  //---//
                  break inf_leave;
                }
                break;
              case 2:                             /* dynamic block */
                //Tracev((stderr, "inflate:     dynamic codes block%s\n",
                //        state.last ? " (last)" : ""));
                state.mode = TABLE;
                break;
              case 3:
                strm.msg = 'invalid block type';
                state.mode = BAD$1;
            }
            //--- DROPBITS(2) ---//
            hold >>>= 2;
            bits -= 2;
            //---//
            break;
          case STORED:
            //--- BYTEBITS() ---// /* go to byte boundary */
            hold >>>= bits & 7;
            bits -= bits & 7;
            //---//
            //=== NEEDBITS(32); */
            while (bits < 32) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
              strm.msg = 'invalid stored block lengths';
              state.mode = BAD$1;
              break;
            }
            state.length = hold & 0xffff;
            //Tracev((stderr, "inflate:       stored length %u\n",
            //        state.length));
            //=== INITBITS();
            hold = 0;
            bits = 0;
            //===//
            state.mode = COPY_;
            if (flush === Z_TREES) { break inf_leave; }
            /* falls through */
          case COPY_:
            state.mode = COPY;
            /* falls through */
          case COPY:
            copy = state.length;
            if (copy) {
              if (copy > have) { copy = have; }
              if (copy > left) { copy = left; }
              if (copy === 0) { break inf_leave; }
              //--- zmemcpy(put, next, copy); ---
              output.set(input.subarray(next, next + copy), put);
              //---//
              have -= copy;
              next += copy;
              left -= copy;
              put += copy;
              state.length -= copy;
              break;
            }
            //Tracev((stderr, "inflate:       stored end\n"));
            state.mode = TYPE$1;
            break;
          case TABLE:
            //=== NEEDBITS(14); */
            while (bits < 14) {
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            //===//
            state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
            //--- DROPBITS(5) ---//
            hold >>>= 5;
            bits -= 5;
            //---//
            state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
            //--- DROPBITS(5) ---//
            hold >>>= 5;
            bits -= 5;
            //---//
            state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
            //--- DROPBITS(4) ---//
            hold >>>= 4;
            bits -= 4;
            //---//
    //#ifndef PKZIP_BUG_WORKAROUND
            if (state.nlen > 286 || state.ndist > 30) {
              strm.msg = 'too many length or distance symbols';
              state.mode = BAD$1;
              break;
            }
    //#endif
            //Tracev((stderr, "inflate:       table sizes ok\n"));
            state.have = 0;
            state.mode = LENLENS;
            /* falls through */
          case LENLENS:
            while (state.have < state.ncode) {
              //=== NEEDBITS(3);
              while (bits < 3) {
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
              }
              //===//
              state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
              //--- DROPBITS(3) ---//
              hold >>>= 3;
              bits -= 3;
              //---//
            }
            while (state.have < 19) {
              state.lens[order[state.have++]] = 0;
            }
            // We have separate tables & no pointers. 2 commented lines below not needed.
            //state.next = state.codes;
            //state.lencode = state.next;
            // Switch to use dynamic table
            state.lencode = state.lendyn;
            state.lenbits = 7;

            opts = { bits: state.lenbits };
            ret = inftrees(CODES$1, state.lens, 0, 19, state.lencode, 0, state.work, opts);
            state.lenbits = opts.bits;

            if (ret) {
              strm.msg = 'invalid code lengths set';
              state.mode = BAD$1;
              break;
            }
            //Tracev((stderr, "inflate:       code lengths ok\n"));
            state.have = 0;
            state.mode = CODELENS;
            /* falls through */
          case CODELENS:
            while (state.have < state.nlen + state.ndist) {
              for (;;) {
                here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
                here_bits = here >>> 24;
                here_op = (here >>> 16) & 0xff;
                here_val = here & 0xffff;

                if ((here_bits) <= bits) { break; }
                //--- PULLBYTE() ---//
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
                //---//
              }
              if (here_val < 16) {
                //--- DROPBITS(here.bits) ---//
                hold >>>= here_bits;
                bits -= here_bits;
                //---//
                state.lens[state.have++] = here_val;
              }
              else {
                if (here_val === 16) {
                  //=== NEEDBITS(here.bits + 2);
                  n = here_bits + 2;
                  while (bits < n) {
                    if (have === 0) { break inf_leave; }
                    have--;
                    hold += input[next++] << bits;
                    bits += 8;
                  }
                  //===//
                  //--- DROPBITS(here.bits) ---//
                  hold >>>= here_bits;
                  bits -= here_bits;
                  //---//
                  if (state.have === 0) {
                    strm.msg = 'invalid bit length repeat';
                    state.mode = BAD$1;
                    break;
                  }
                  len = state.lens[state.have - 1];
                  copy = 3 + (hold & 0x03);//BITS(2);
                  //--- DROPBITS(2) ---//
                  hold >>>= 2;
                  bits -= 2;
                  //---//
                }
                else if (here_val === 17) {
                  //=== NEEDBITS(here.bits + 3);
                  n = here_bits + 3;
                  while (bits < n) {
                    if (have === 0) { break inf_leave; }
                    have--;
                    hold += input[next++] << bits;
                    bits += 8;
                  }
                  //===//
                  //--- DROPBITS(here.bits) ---//
                  hold >>>= here_bits;
                  bits -= here_bits;
                  //---//
                  len = 0;
                  copy = 3 + (hold & 0x07);//BITS(3);
                  //--- DROPBITS(3) ---//
                  hold >>>= 3;
                  bits -= 3;
                  //---//
                }
                else {
                  //=== NEEDBITS(here.bits + 7);
                  n = here_bits + 7;
                  while (bits < n) {
                    if (have === 0) { break inf_leave; }
                    have--;
                    hold += input[next++] << bits;
                    bits += 8;
                  }
                  //===//
                  //--- DROPBITS(here.bits) ---//
                  hold >>>= here_bits;
                  bits -= here_bits;
                  //---//
                  len = 0;
                  copy = 11 + (hold & 0x7f);//BITS(7);
                  //--- DROPBITS(7) ---//
                  hold >>>= 7;
                  bits -= 7;
                  //---//
                }
                if (state.have + copy > state.nlen + state.ndist) {
                  strm.msg = 'invalid bit length repeat';
                  state.mode = BAD$1;
                  break;
                }
                while (copy--) {
                  state.lens[state.have++] = len;
                }
              }
            }

            /* handle error breaks in while */
            if (state.mode === BAD$1) { break; }

            /* check for end-of-block code (better have one) */
            if (state.lens[256] === 0) {
              strm.msg = 'invalid code -- missing end-of-block';
              state.mode = BAD$1;
              break;
            }

            /* build code tables -- note: do not change the lenbits or distbits
               values here (9 and 6) without reading the comments in inftrees.h
               concerning the ENOUGH constants, which depend on those values */
            state.lenbits = 9;

            opts = { bits: state.lenbits };
            ret = inftrees(LENS$1, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
            // We have separate tables & no pointers. 2 commented lines below not needed.
            // state.next_index = opts.table_index;
            state.lenbits = opts.bits;
            // state.lencode = state.next;

            if (ret) {
              strm.msg = 'invalid literal/lengths set';
              state.mode = BAD$1;
              break;
            }

            state.distbits = 6;
            //state.distcode.copy(state.codes);
            // Switch to use dynamic table
            state.distcode = state.distdyn;
            opts = { bits: state.distbits };
            ret = inftrees(DISTS$1, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
            // We have separate tables & no pointers. 2 commented lines below not needed.
            // state.next_index = opts.table_index;
            state.distbits = opts.bits;
            // state.distcode = state.next;

            if (ret) {
              strm.msg = 'invalid distances set';
              state.mode = BAD$1;
              break;
            }
            //Tracev((stderr, 'inflate:       codes ok\n'));
            state.mode = LEN_;
            if (flush === Z_TREES) { break inf_leave; }
            /* falls through */
          case LEN_:
            state.mode = LEN;
            /* falls through */
          case LEN:
            if (have >= 6 && left >= 258) {
              //--- RESTORE() ---
              strm.next_out = put;
              strm.avail_out = left;
              strm.next_in = next;
              strm.avail_in = have;
              state.hold = hold;
              state.bits = bits;
              //---
              inffast(strm, _out);
              //--- LOAD() ---
              put = strm.next_out;
              output = strm.output;
              left = strm.avail_out;
              next = strm.next_in;
              input = strm.input;
              have = strm.avail_in;
              hold = state.hold;
              bits = state.bits;
              //---

              if (state.mode === TYPE$1) {
                state.back = -1;
              }
              break;
            }
            state.back = 0;
            for (;;) {
              here = state.lencode[hold & ((1 << state.lenbits) - 1)];  /*BITS(state.lenbits)*/
              here_bits = here >>> 24;
              here_op = (here >>> 16) & 0xff;
              here_val = here & 0xffff;

              if (here_bits <= bits) { break; }
              //--- PULLBYTE() ---//
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
              //---//
            }
            if (here_op && (here_op & 0xf0) === 0) {
              last_bits = here_bits;
              last_op = here_op;
              last_val = here_val;
              for (;;) {
                here = state.lencode[last_val +
                        ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
                here_bits = here >>> 24;
                here_op = (here >>> 16) & 0xff;
                here_val = here & 0xffff;

                if ((last_bits + here_bits) <= bits) { break; }
                //--- PULLBYTE() ---//
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
                //---//
              }
              //--- DROPBITS(last.bits) ---//
              hold >>>= last_bits;
              bits -= last_bits;
              //---//
              state.back += last_bits;
            }
            //--- DROPBITS(here.bits) ---//
            hold >>>= here_bits;
            bits -= here_bits;
            //---//
            state.back += here_bits;
            state.length = here_val;
            if (here_op === 0) {
              //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
              //        "inflate:         literal '%c'\n" :
              //        "inflate:         literal 0x%02x\n", here.val));
              state.mode = LIT;
              break;
            }
            if (here_op & 32) {
              //Tracevv((stderr, "inflate:         end of block\n"));
              state.back = -1;
              state.mode = TYPE$1;
              break;
            }
            if (here_op & 64) {
              strm.msg = 'invalid literal/length code';
              state.mode = BAD$1;
              break;
            }
            state.extra = here_op & 15;
            state.mode = LENEXT;
            /* falls through */
          case LENEXT:
            if (state.extra) {
              //=== NEEDBITS(state.extra);
              n = state.extra;
              while (bits < n) {
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
              }
              //===//
              state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
              //--- DROPBITS(state.extra) ---//
              hold >>>= state.extra;
              bits -= state.extra;
              //---//
              state.back += state.extra;
            }
            //Tracevv((stderr, "inflate:         length %u\n", state.length));
            state.was = state.length;
            state.mode = DIST;
            /* falls through */
          case DIST:
            for (;;) {
              here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
              here_bits = here >>> 24;
              here_op = (here >>> 16) & 0xff;
              here_val = here & 0xffff;

              if ((here_bits) <= bits) { break; }
              //--- PULLBYTE() ---//
              if (have === 0) { break inf_leave; }
              have--;
              hold += input[next++] << bits;
              bits += 8;
              //---//
            }
            if ((here_op & 0xf0) === 0) {
              last_bits = here_bits;
              last_op = here_op;
              last_val = here_val;
              for (;;) {
                here = state.distcode[last_val +
                        ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
                here_bits = here >>> 24;
                here_op = (here >>> 16) & 0xff;
                here_val = here & 0xffff;

                if ((last_bits + here_bits) <= bits) { break; }
                //--- PULLBYTE() ---//
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
                //---//
              }
              //--- DROPBITS(last.bits) ---//
              hold >>>= last_bits;
              bits -= last_bits;
              //---//
              state.back += last_bits;
            }
            //--- DROPBITS(here.bits) ---//
            hold >>>= here_bits;
            bits -= here_bits;
            //---//
            state.back += here_bits;
            if (here_op & 64) {
              strm.msg = 'invalid distance code';
              state.mode = BAD$1;
              break;
            }
            state.offset = here_val;
            state.extra = (here_op) & 15;
            state.mode = DISTEXT;
            /* falls through */
          case DISTEXT:
            if (state.extra) {
              //=== NEEDBITS(state.extra);
              n = state.extra;
              while (bits < n) {
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
              }
              //===//
              state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
              //--- DROPBITS(state.extra) ---//
              hold >>>= state.extra;
              bits -= state.extra;
              //---//
              state.back += state.extra;
            }
    //#ifdef INFLATE_STRICT
            if (state.offset > state.dmax) {
              strm.msg = 'invalid distance too far back';
              state.mode = BAD$1;
              break;
            }
    //#endif
            //Tracevv((stderr, "inflate:         distance %u\n", state.offset));
            state.mode = MATCH;
            /* falls through */
          case MATCH:
            if (left === 0) { break inf_leave; }
            copy = _out - left;
            if (state.offset > copy) {         /* copy from window */
              copy = state.offset - copy;
              if (copy > state.whave) {
                if (state.sane) {
                  strm.msg = 'invalid distance too far back';
                  state.mode = BAD$1;
                  break;
                }
    // (!) This block is disabled in zlib defaults,
    // don't enable it for binary compatibility
    //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
    //          Trace((stderr, "inflate.c too far\n"));
    //          copy -= state.whave;
    //          if (copy > state.length) { copy = state.length; }
    //          if (copy > left) { copy = left; }
    //          left -= copy;
    //          state.length -= copy;
    //          do {
    //            output[put++] = 0;
    //          } while (--copy);
    //          if (state.length === 0) { state.mode = LEN; }
    //          break;
    //#endif
              }
              if (copy > state.wnext) {
                copy -= state.wnext;
                from = state.wsize - copy;
              }
              else {
                from = state.wnext - copy;
              }
              if (copy > state.length) { copy = state.length; }
              from_source = state.window;
            }
            else {                              /* copy from output */
              from_source = output;
              from = put - state.offset;
              copy = state.length;
            }
            if (copy > left) { copy = left; }
            left -= copy;
            state.length -= copy;
            do {
              output[put++] = from_source[from++];
            } while (--copy);
            if (state.length === 0) { state.mode = LEN; }
            break;
          case LIT:
            if (left === 0) { break inf_leave; }
            output[put++] = state.length;
            left--;
            state.mode = LEN;
            break;
          case CHECK:
            if (state.wrap) {
              //=== NEEDBITS(32);
              while (bits < 32) {
                if (have === 0) { break inf_leave; }
                have--;
                // Use '|' instead of '+' to make sure that result is signed
                hold |= input[next++] << bits;
                bits += 8;
              }
              //===//
              _out -= left;
              strm.total_out += _out;
              state.total += _out;
              if (_out) {
                strm.adler = state.check =
                    /*UPDATE(state.check, put - _out, _out);*/
                    (state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out));

              }
              _out = left;
              // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
              if ((state.flags ? hold : zswap32(hold)) !== state.check) {
                strm.msg = 'incorrect data check';
                state.mode = BAD$1;
                break;
              }
              //=== INITBITS();
              hold = 0;
              bits = 0;
              //===//
              //Tracev((stderr, "inflate:   check matches trailer\n"));
            }
            state.mode = LENGTH;
            /* falls through */
          case LENGTH:
            if (state.wrap && state.flags) {
              //=== NEEDBITS(32);
              while (bits < 32) {
                if (have === 0) { break inf_leave; }
                have--;
                hold += input[next++] << bits;
                bits += 8;
              }
              //===//
              if (hold !== (state.total & 0xffffffff)) {
                strm.msg = 'incorrect length check';
                state.mode = BAD$1;
                break;
              }
              //=== INITBITS();
              hold = 0;
              bits = 0;
              //===//
              //Tracev((stderr, "inflate:   length matches trailer\n"));
            }
            state.mode = DONE;
            /* falls through */
          case DONE:
            ret = Z_STREAM_END$2;
            break inf_leave;
          case BAD$1:
            ret = Z_DATA_ERROR$1;
            break inf_leave;
          case MEM:
            return Z_MEM_ERROR;
          case SYNC:
            /* falls through */
          default:
            return Z_STREAM_ERROR$1;
        }
      }

      // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"

      /*
         Return from inflate(), updating the total counts and the check value.
         If there was no progress during the inflate() call, return a buffer
         error.  Call updatewindow() to create and/or update the window state.
         Note: a memory error from inflate() is non-recoverable.
       */

      //--- RESTORE() ---
      strm.next_out = put;
      strm.avail_out = left;
      strm.next_in = next;
      strm.avail_in = have;
      state.hold = hold;
      state.bits = bits;
      //---

      if (state.wsize || (_out !== strm.avail_out && state.mode < BAD$1 &&
                          (state.mode < CHECK || flush !== Z_FINISH$2))) {
        if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) ;
      }
      _in -= strm.avail_in;
      _out -= strm.avail_out;
      strm.total_in += _in;
      strm.total_out += _out;
      state.total += _out;
      if (state.wrap && _out) {
        strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
          (state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out));
      }
      strm.data_type = state.bits + (state.last ? 64 : 0) +
                        (state.mode === TYPE$1 ? 128 : 0) +
                        (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
      if (((_in === 0 && _out === 0) || flush === Z_FINISH$2) && ret === Z_OK$2) {
        ret = Z_BUF_ERROR$1;
      }
      return ret;
    };


    const inflateEnd = (strm) => {

      if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
        return Z_STREAM_ERROR$1;
      }

      let state = strm.state;
      if (state.window) {
        state.window = null;
      }
      strm.state = null;
      return Z_OK$2;
    };


    const inflateGetHeader = (strm, head) => {

      /* check state */
      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
      const state = strm.state;
      if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR$1; }

      /* save header structure */
      state.head = head;
      head.done = false;
      return Z_OK$2;
    };


    const inflateSetDictionary = (strm, dictionary) => {
      const dictLength = dictionary.length;

      let state;
      let dictid;
      let ret;

      /* check state */
      if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR$1; }
      state = strm.state;

      if (state.wrap !== 0 && state.mode !== DICT) {
        return Z_STREAM_ERROR$1;
      }

      /* check for correct dictionary identifier */
      if (state.mode === DICT) {
        dictid = 1; /* adler32(0, null, 0)*/
        /* dictid = adler32(dictid, dictionary, dictLength); */
        dictid = adler32_1(dictid, dictionary, dictLength, 0);
        if (dictid !== state.check) {
          return Z_DATA_ERROR$1;
        }
      }
      /* copy dictionary to window using updatewindow(), which will amend the
       existing dictionary if appropriate */
      ret = updatewindow(strm, dictionary, dictLength, dictLength);
      if (ret) {
        state.mode = MEM;
        return Z_MEM_ERROR;
      }
      state.havedict = 1;
      // Tracev((stderr, "inflate:   dictionary set\n"));
      return Z_OK$2;
    };


    var inflateReset_1 = inflateReset;
    var inflateReset2_1 = inflateReset2;
    var inflateResetKeep_1 = inflateResetKeep;
    var inflateInit_1 = inflateInit;
    var inflateInit2_1 = inflateInit2;
    var inflate_2 = inflate;
    var inflateEnd_1 = inflateEnd;
    var inflateGetHeader_1 = inflateGetHeader;
    var inflateSetDictionary_1 = inflateSetDictionary;
    var inflateInfo = 'pako inflate (from Nodeca project)';

    /* Not implemented
    module.exports.inflateCopy = inflateCopy;
    module.exports.inflateGetDictionary = inflateGetDictionary;
    module.exports.inflateMark = inflateMark;
    module.exports.inflatePrime = inflatePrime;
    module.exports.inflateSync = inflateSync;
    module.exports.inflateSyncPoint = inflateSyncPoint;
    module.exports.inflateUndermine = inflateUndermine;
    */

    var inflate_1 = {
        inflateReset: inflateReset_1,
        inflateReset2: inflateReset2_1,
        inflateResetKeep: inflateResetKeep_1,
        inflateInit: inflateInit_1,
        inflateInit2: inflateInit2_1,
        inflate: inflate_2,
        inflateEnd: inflateEnd_1,
        inflateGetHeader: inflateGetHeader_1,
        inflateSetDictionary: inflateSetDictionary_1,
        inflateInfo: inflateInfo
    };

    // (C) 1995-2013 Jean-loup Gailly and Mark Adler
    // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
    //
    // This software is provided 'as-is', without any express or implied
    // warranty. In no event will the authors be held liable for any damages
    // arising from the use of this software.
    //
    // Permission is granted to anyone to use this software for any purpose,
    // including commercial applications, and to alter it and redistribute it
    // freely, subject to the following restrictions:
    //
    // 1. The origin of this software must not be misrepresented; you must not
    //   claim that you wrote the original software. If you use this software
    //   in a product, an acknowledgment in the product documentation would be
    //   appreciated but is not required.
    // 2. Altered source versions must be plainly marked as such, and must not be
    //   misrepresented as being the original software.
    // 3. This notice may not be removed or altered from any source distribution.

    function GZheader() {
      /* true if compressed data believed to be text */
      this.text       = 0;
      /* modification time */
      this.time       = 0;
      /* extra flags (not used when writing a gzip file) */
      this.xflags     = 0;
      /* operating system */
      this.os         = 0;
      /* pointer to extra field or Z_NULL if none */
      this.extra      = null;
      /* extra field length (valid if extra != Z_NULL) */
      this.extra_len  = 0; // Actually, we don't need it in JS,
                           // but leave for few code modifications

      //
      // Setup limits is not necessary because in js we should not preallocate memory
      // for inflate use constant limit in 65536 bytes
      //

      /* space at extra (only when reading header) */
      // this.extra_max  = 0;
      /* pointer to zero-terminated file name or Z_NULL */
      this.name       = '';
      /* space at name (only when reading header) */
      // this.name_max   = 0;
      /* pointer to zero-terminated comment or Z_NULL */
      this.comment    = '';
      /* space at comment (only when reading header) */
      // this.comm_max   = 0;
      /* true if there was or will be a header crc */
      this.hcrc       = 0;
      /* true when done reading gzip header (not used when writing a gzip file) */
      this.done       = false;
    }

    var gzheader = GZheader;

    const toString$1 = Object.prototype.toString;

    /* Public constants ==========================================================*/
    /* ===========================================================================*/

    const {
      Z_NO_FLUSH: Z_NO_FLUSH$2, Z_FINISH: Z_FINISH$3,
      Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_MEM_ERROR: Z_MEM_ERROR$1
    } = constants;

    /* ===========================================================================*/


    /**
     * class Inflate
     *
     * Generic JS-style wrapper for zlib calls. If you don't need
     * streaming behaviour - use more simple functions: [[inflate]]
     * and [[inflateRaw]].
     **/

    /* internal
     * inflate.chunks -> Array
     *
     * Chunks of output data, if [[Inflate#onData]] not overridden.
     **/

    /**
     * Inflate.result -> Uint8Array|String
     *
     * Uncompressed result, generated by default [[Inflate#onData]]
     * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
     * (call [[Inflate#push]] with `Z_FINISH` / `true` param).
     **/

    /**
     * Inflate.err -> Number
     *
     * Error code after inflate finished. 0 (Z_OK) on success.
     * Should be checked if broken data possible.
     **/

    /**
     * Inflate.msg -> String
     *
     * Error message, if [[Inflate.err]] != 0
     **/


    /**
     * new Inflate(options)
     * - options (Object): zlib inflate options.
     *
     * Creates new inflator instance with specified params. Throws exception
     * on bad params. Supported options:
     *
     * - `windowBits`
     * - `dictionary`
     *
     * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
     * for more information on these.
     *
     * Additional options, for internal needs:
     *
     * - `chunkSize` - size of generated data chunks (16K by default)
     * - `raw` (Boolean) - do raw inflate
     * - `to` (String) - if equal to 'string', then result will be converted
     *   from utf8 to utf16 (javascript) string. When string output requested,
     *   chunk length can differ from `chunkSize`, depending on content.
     *
     * By default, when no options set, autodetect deflate/gzip data format via
     * wrapper header.
     *
     * ##### Example:
     *
     * ```javascript
     * const pako = require('pako')
     * const chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])
     * const chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);
     *
     * const inflate = new pako.Inflate({ level: 3});
     *
     * inflate.push(chunk1, false);
     * inflate.push(chunk2, true);  // true -> last chunk
     *
     * if (inflate.err) { throw new Error(inflate.err); }
     *
     * console.log(inflate.result);
     * ```
     **/
    function Inflate(options) {
      this.options = common.assign({
        chunkSize: 1024 * 64,
        windowBits: 15,
        to: ''
      }, options || {});

      const opt = this.options;

      // Force window size for `raw` data, if not set directly,
      // because we have no header for autodetect.
      if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
        opt.windowBits = -opt.windowBits;
        if (opt.windowBits === 0) { opt.windowBits = -15; }
      }

      // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
      if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
          !(options && options.windowBits)) {
        opt.windowBits += 32;
      }

      // Gzip header has no info about windows size, we can do autodetect only
      // for deflate. So, if window size not set, force it to max when gzip possible
      if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
        // bit 3 (16) -> gzipped data
        // bit 4 (32) -> autodetect gzip/deflate
        if ((opt.windowBits & 15) === 0) {
          opt.windowBits |= 15;
        }
      }

      this.err    = 0;      // error code, if happens (0 = Z_OK)
      this.msg    = '';     // error message
      this.ended  = false;  // used to avoid multiple onEnd() calls
      this.chunks = [];     // chunks of compressed data

      this.strm   = new zstream();
      this.strm.avail_out = 0;

      let status  = inflate_1.inflateInit2(
        this.strm,
        opt.windowBits
      );

      if (status !== Z_OK$3) {
        throw new Error(messages[status]);
      }

      this.header = new gzheader();

      inflate_1.inflateGetHeader(this.strm, this.header);

      // Setup dictionary
      if (opt.dictionary) {
        // Convert data if needed
        if (typeof opt.dictionary === 'string') {
          opt.dictionary = strings.string2buf(opt.dictionary);
        } else if (toString$1.call(opt.dictionary) === '[object ArrayBuffer]') {
          opt.dictionary = new Uint8Array(opt.dictionary);
        }
        if (opt.raw) { //In raw mode we need to set the dictionary early
          status = inflate_1.inflateSetDictionary(this.strm, opt.dictionary);
          if (status !== Z_OK$3) {
            throw new Error(messages[status]);
          }
        }
      }
    }

    /**
     * Inflate#push(data[, flush_mode]) -> Boolean
     * - data (Uint8Array|ArrayBuffer): input data
     * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE
     *   flush modes. See constants. Skipped or `false` means Z_NO_FLUSH,
     *   `true` means Z_FINISH.
     *
     * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
     * new output chunks. Returns `true` on success. If end of stream detected,
     * [[Inflate#onEnd]] will be called.
     *
     * `flush_mode` is not needed for normal operation, because end of stream
     * detected automatically. You may try to use it for advanced things, but
     * this functionality was not tested.
     *
     * On fail call [[Inflate#onEnd]] with error code and return false.
     *
     * ##### Example
     *
     * ```javascript
     * push(chunk, false); // push one of data chunks
     * ...
     * push(chunk, true);  // push last chunk
     * ```
     **/
    Inflate.prototype.push = function (data, flush_mode) {
      const strm = this.strm;
      const chunkSize = this.options.chunkSize;
      const dictionary = this.options.dictionary;
      let status, _flush_mode, last_avail_out;

      if (this.ended) return false;

      if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;
      else _flush_mode = flush_mode === true ? Z_FINISH$3 : Z_NO_FLUSH$2;

      // Convert data if needed
      if (toString$1.call(data) === '[object ArrayBuffer]') {
        strm.input = new Uint8Array(data);
      } else {
        strm.input = data;
      }

      strm.next_in = 0;
      strm.avail_in = strm.input.length;

      for (;;) {
        if (strm.avail_out === 0) {
          strm.output = new Uint8Array(chunkSize);
          strm.next_out = 0;
          strm.avail_out = chunkSize;
        }

        status = inflate_1.inflate(strm, _flush_mode);

        if (status === Z_NEED_DICT$1 && dictionary) {
          status = inflate_1.inflateSetDictionary(strm, dictionary);

          if (status === Z_OK$3) {
            status = inflate_1.inflate(strm, _flush_mode);
          } else if (status === Z_DATA_ERROR$2) {
            // Replace code with more verbose
            status = Z_NEED_DICT$1;
          }
        }

        // Skip snyc markers if more data follows and not raw mode
        while (strm.avail_in > 0 &&
               status === Z_STREAM_END$3 &&
               strm.state.wrap > 0 &&
               data[strm.next_in] !== 0)
        {
          inflate_1.inflateReset(strm);
          status = inflate_1.inflate(strm, _flush_mode);
        }

        switch (status) {
          case Z_STREAM_ERROR$2:
          case Z_DATA_ERROR$2:
          case Z_NEED_DICT$1:
          case Z_MEM_ERROR$1:
            this.onEnd(status);
            this.ended = true;
            return false;
        }

        // Remember real `avail_out` value, because we may patch out buffer content
        // to align utf8 strings boundaries.
        last_avail_out = strm.avail_out;

        if (strm.next_out) {
          if (strm.avail_out === 0 || status === Z_STREAM_END$3) {

            if (this.options.to === 'string') {

              let next_out_utf8 = strings.utf8border(strm.output, strm.next_out);

              let tail = strm.next_out - next_out_utf8;
              let utf8str = strings.buf2string(strm.output, next_out_utf8);

              // move tail & realign counters
              strm.next_out = tail;
              strm.avail_out = chunkSize - tail;
              if (tail) strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0);

              this.onData(utf8str);

            } else {
              this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));
            }
          }
        }

        // Must repeat iteration if out buffer is full
        if (status === Z_OK$3 && last_avail_out === 0) continue;

        // Finalize if end of stream reached.
        if (status === Z_STREAM_END$3) {
          status = inflate_1.inflateEnd(this.strm);
          this.onEnd(status);
          this.ended = true;
          return true;
        }

        if (strm.avail_in === 0) break;
      }

      return true;
    };


    /**
     * Inflate#onData(chunk) -> Void
     * - chunk (Uint8Array|String): output data. When string output requested,
     *   each chunk will be string.
     *
     * By default, stores data blocks in `chunks[]` property and glue
     * those in `onEnd`. Override this handler, if you need another behaviour.
     **/
    Inflate.prototype.onData = function (chunk) {
      this.chunks.push(chunk);
    };


    /**
     * Inflate#onEnd(status) -> Void
     * - status (Number): inflate status. 0 (Z_OK) on success,
     *   other if not.
     *
     * Called either after you tell inflate that the input stream is
     * complete (Z_FINISH). By default - join collected chunks,
     * free memory and fill `results` / `err` properties.
     **/
    Inflate.prototype.onEnd = function (status) {
      // On success - join
      if (status === Z_OK$3) {
        if (this.options.to === 'string') {
          this.result = this.chunks.join('');
        } else {
          this.result = common.flattenChunks(this.chunks);
        }
      }
      this.chunks = [];
      this.err = status;
      this.msg = this.strm.msg;
    };


    /**
     * inflate(data[, options]) -> Uint8Array|String
     * - data (Uint8Array): input data to decompress.
     * - options (Object): zlib inflate options.
     *
     * Decompress `data` with inflate/ungzip and `options`. Autodetect
     * format via wrapper header by default. That's why we don't provide
     * separate `ungzip` method.
     *
     * Supported options are:
     *
     * - windowBits
     *
     * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
     * for more information.
     *
     * Sugar (options):
     *
     * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
     *   negative windowBits implicitly.
     * - `to` (String) - if equal to 'string', then result will be converted
     *   from utf8 to utf16 (javascript) string. When string output requested,
     *   chunk length can differ from `chunkSize`, depending on content.
     *
     *
     * ##### Example:
     *
     * ```javascript
     * const pako = require('pako');
     * const input = pako.deflate(new Uint8Array([1,2,3,4,5,6,7,8,9]));
     * let output;
     *
     * try {
     *   output = pako.inflate(input);
     * } catch (err)
     *   console.log(err);
     * }
     * ```
     **/
    function inflate$1(input, options) {
      const inflator = new Inflate(options);

      inflator.push(input);

      // That will never happens, if you don't cheat with options :)
      if (inflator.err) throw inflator.msg || messages[inflator.err];

      return inflator.result;
    }


    /**
     * inflateRaw(data[, options]) -> Uint8Array|String
     * - data (Uint8Array): input data to decompress.
     * - options (Object): zlib inflate options.
     *
     * The same as [[inflate]], but creates raw data, without wrapper
     * (header and adler32 crc).
     **/
    function inflateRaw(input, options) {
      options = options || {};
      options.raw = true;
      return inflate$1(input, options);
    }


    /**
     * ungzip(data[, options]) -> Uint8Array|String
     * - data (Uint8Array): input data to decompress.
     * - options (Object): zlib inflate options.
     *
     * Just shortcut to [[inflate]], because it autodetects format
     * by header.content. Done for convenience.
     **/


    var Inflate_1 = Inflate;
    var inflate_2$1 = inflate$1;
    var inflateRaw_1 = inflateRaw;
    var ungzip = inflate$1;
    var constants$2 = constants;

    var inflate_1$1 = {
        Inflate: Inflate_1,
        inflate: inflate_2$1,
        inflateRaw: inflateRaw_1,
        ungzip: ungzip,
        constants: constants$2
    };

    const { Inflate: Inflate$1, inflate: inflate$2, inflateRaw: inflateRaw$1, ungzip: ungzip$1 } = inflate_1$1;
    var inflate_1$2 = inflate$2;

    /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
    var read = function (buffer, offset, isLE, mLen, nBytes) {
      var e, m;
      var eLen = (nBytes * 8) - mLen - 1;
      var eMax = (1 << eLen) - 1;
      var eBias = eMax >> 1;
      var nBits = -7;
      var i = isLE ? (nBytes - 1) : 0;
      var d = isLE ? -1 : 1;
      var s = buffer[offset + i];

      i += d;

      e = s & ((1 << (-nBits)) - 1);
      s >>= (-nBits);
      nBits += eLen;
      for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

      m = e & ((1 << (-nBits)) - 1);
      e >>= (-nBits);
      nBits += mLen;
      for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

      if (e === 0) {
        e = 1 - eBias;
      } else if (e === eMax) {
        return m ? NaN : ((s ? -1 : 1) * Infinity)
      } else {
        m = m + Math.pow(2, mLen);
        e = e - eBias;
      }
      return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
    };

    var write = function (buffer, value, offset, isLE, mLen, nBytes) {
      var e, m, c;
      var eLen = (nBytes * 8) - mLen - 1;
      var eMax = (1 << eLen) - 1;
      var eBias = eMax >> 1;
      var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
      var i = isLE ? 0 : (nBytes - 1);
      var d = isLE ? 1 : -1;
      var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

      value = Math.abs(value);

      if (isNaN(value) || value === Infinity) {
        m = isNaN(value) ? 1 : 0;
        e = eMax;
      } else {
        e = Math.floor(Math.log(value) / Math.LN2);
        if (value * (c = Math.pow(2, -e)) < 1) {
          e--;
          c *= 2;
        }
        if (e + eBias >= 1) {
          value += rt / c;
        } else {
          value += rt * Math.pow(2, 1 - eBias);
        }
        if (value * c >= 2) {
          e++;
          c /= 2;
        }

        if (e + eBias >= eMax) {
          m = 0;
          e = eMax;
        } else if (e + eBias >= 1) {
          m = ((value * c) - 1) * Math.pow(2, mLen);
          e = e + eBias;
        } else {
          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
          e = 0;
        }
      }

      for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

      e = (e << mLen) | m;
      eLen += mLen;
      for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

      buffer[offset + i - d] |= s * 128;
    };

    var ieee754 = {
        read: read,
        write: write
    };

    var pbf = Pbf;



    function Pbf(buf) {
        this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
        this.pos = 0;
        this.type = 0;
        this.length = this.buf.length;
    }

    Pbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum
    Pbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64
    Pbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields
    Pbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32

    var SHIFT_LEFT_32 = (1 << 16) * (1 << 16),
        SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;

    // Threshold chosen based on both benchmarking and knowledge about browser string
    // data structures (which currently switch structure types at 12 bytes or more)
    var TEXT_DECODER_MIN_LENGTH = 12;
    var utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf8');

    Pbf.prototype = {

        destroy: function() {
            this.buf = null;
        },

        // === READING =================================================================

        readFields: function(readField, result, end) {
            end = end || this.length;

            while (this.pos < end) {
                var val = this.readVarint(),
                    tag = val >> 3,
                    startPos = this.pos;

                this.type = val & 0x7;
                readField(tag, result, this);

                if (this.pos === startPos) this.skip(val);
            }
            return result;
        },

        readMessage: function(readField, result) {
            return this.readFields(readField, result, this.readVarint() + this.pos);
        },

        readFixed32: function() {
            var val = readUInt32(this.buf, this.pos);
            this.pos += 4;
            return val;
        },

        readSFixed32: function() {
            var val = readInt32(this.buf, this.pos);
            this.pos += 4;
            return val;
        },

        // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)

        readFixed64: function() {
            var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
            this.pos += 8;
            return val;
        },

        readSFixed64: function() {
            var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
            this.pos += 8;
            return val;
        },

        readFloat: function() {
            var val = ieee754.read(this.buf, this.pos, true, 23, 4);
            this.pos += 4;
            return val;
        },

        readDouble: function() {
            var val = ieee754.read(this.buf, this.pos, true, 52, 8);
            this.pos += 8;
            return val;
        },

        readVarint: function(isSigned) {
            var buf = this.buf,
                val, b;

            b = buf[this.pos++]; val  =  b & 0x7f;        if (b < 0x80) return val;
            b = buf[this.pos++]; val |= (b & 0x7f) << 7;  if (b < 0x80) return val;
            b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;
            b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;
            b = buf[this.pos];   val |= (b & 0x0f) << 28;

            return readVarintRemainder(val, isSigned, this);
        },

        readVarint64: function() { // for compatibility with v2.0.1
            return this.readVarint(true);
        },

        readSVarint: function() {
            var num = this.readVarint();
            return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
        },

        readBoolean: function() {
            return Boolean(this.readVarint());
        },

        readString: function() {
            var end = this.readVarint() + this.pos;
            var pos = this.pos;
            this.pos = end;

            if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
                // longer strings are fast with the built-in browser TextDecoder API
                return readUtf8TextDecoder(this.buf, pos, end);
            }
            // short strings are fast with our custom implementation
            return readUtf8(this.buf, pos, end);
        },

        readBytes: function() {
            var end = this.readVarint() + this.pos,
                buffer = this.buf.subarray(this.pos, end);
            this.pos = end;
            return buffer;
        },

        // verbose for performance reasons; doesn't affect gzipped size

        readPackedVarint: function(arr, isSigned) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readVarint(isSigned));
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readVarint(isSigned));
            return arr;
        },
        readPackedSVarint: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readSVarint());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readSVarint());
            return arr;
        },
        readPackedBoolean: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readBoolean());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readBoolean());
            return arr;
        },
        readPackedFloat: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readFloat());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readFloat());
            return arr;
        },
        readPackedDouble: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readDouble());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readDouble());
            return arr;
        },
        readPackedFixed32: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readFixed32());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readFixed32());
            return arr;
        },
        readPackedSFixed32: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed32());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readSFixed32());
            return arr;
        },
        readPackedFixed64: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readFixed64());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readFixed64());
            return arr;
        },
        readPackedSFixed64: function(arr) {
            if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed64());
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readSFixed64());
            return arr;
        },

        skip: function(val) {
            var type = val & 0x7;
            if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}
            else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;
            else if (type === Pbf.Fixed32) this.pos += 4;
            else if (type === Pbf.Fixed64) this.pos += 8;
            else throw new Error('Unimplemented type: ' + type);
        },

        // === WRITING =================================================================

        writeTag: function(tag, type) {
            this.writeVarint((tag << 3) | type);
        },

        realloc: function(min) {
            var length = this.length || 16;

            while (length < this.pos + min) length *= 2;

            if (length !== this.length) {
                var buf = new Uint8Array(length);
                buf.set(this.buf);
                this.buf = buf;
                this.length = length;
            }
        },

        finish: function() {
            this.length = this.pos;
            this.pos = 0;
            return this.buf.subarray(0, this.length);
        },

        writeFixed32: function(val) {
            this.realloc(4);
            writeInt32(this.buf, val, this.pos);
            this.pos += 4;
        },

        writeSFixed32: function(val) {
            this.realloc(4);
            writeInt32(this.buf, val, this.pos);
            this.pos += 4;
        },

        writeFixed64: function(val) {
            this.realloc(8);
            writeInt32(this.buf, val & -1, this.pos);
            writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
            this.pos += 8;
        },

        writeSFixed64: function(val) {
            this.realloc(8);
            writeInt32(this.buf, val & -1, this.pos);
            writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
            this.pos += 8;
        },

        writeVarint: function(val) {
            val = +val || 0;

            if (val > 0xfffffff || val < 0) {
                writeBigVarint(val, this);
                return;
            }

            this.realloc(4);

            this.buf[this.pos++] =           val & 0x7f  | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
            this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
            this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
            this.buf[this.pos++] =   (val >>> 7) & 0x7f;
        },

        writeSVarint: function(val) {
            this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
        },

        writeBoolean: function(val) {
            this.writeVarint(Boolean(val));
        },

        writeString: function(str) {
            str = String(str);
            this.realloc(str.length * 4);

            this.pos++; // reserve 1 byte for short string length

            var startPos = this.pos;
            // write the string directly to the buffer and see how much was written
            this.pos = writeUtf8(this.buf, str, this.pos);
            var len = this.pos - startPos;

            if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);

            // finally, write the message length in the reserved place and restore the position
            this.pos = startPos - 1;
            this.writeVarint(len);
            this.pos += len;
        },

        writeFloat: function(val) {
            this.realloc(4);
            ieee754.write(this.buf, val, this.pos, true, 23, 4);
            this.pos += 4;
        },

        writeDouble: function(val) {
            this.realloc(8);
            ieee754.write(this.buf, val, this.pos, true, 52, 8);
            this.pos += 8;
        },

        writeBytes: function(buffer) {
            var len = buffer.length;
            this.writeVarint(len);
            this.realloc(len);
            for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];
        },

        writeRawMessage: function(fn, obj) {
            this.pos++; // reserve 1 byte for short message length

            // write the message directly to the buffer and see how much was written
            var startPos = this.pos;
            fn(obj, this);
            var len = this.pos - startPos;

            if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);

            // finally, write the message length in the reserved place and restore the position
            this.pos = startPos - 1;
            this.writeVarint(len);
            this.pos += len;
        },

        writeMessage: function(tag, fn, obj) {
            this.writeTag(tag, Pbf.Bytes);
            this.writeRawMessage(fn, obj);
        },

        writePackedVarint:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedVarint, arr);   },
        writePackedSVarint:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);  },
        writePackedBoolean:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);  },
        writePackedFloat:    function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFloat, arr);    },
        writePackedDouble:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedDouble, arr);   },
        writePackedFixed32:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);  },
        writePackedSFixed32: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr); },
        writePackedFixed64:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);  },
        writePackedSFixed64: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed64, arr); },

        writeBytesField: function(tag, buffer) {
            this.writeTag(tag, Pbf.Bytes);
            this.writeBytes(buffer);
        },
        writeFixed32Field: function(tag, val) {
            this.writeTag(tag, Pbf.Fixed32);
            this.writeFixed32(val);
        },
        writeSFixed32Field: function(tag, val) {
            this.writeTag(tag, Pbf.Fixed32);
            this.writeSFixed32(val);
        },
        writeFixed64Field: function(tag, val) {
            this.writeTag(tag, Pbf.Fixed64);
            this.writeFixed64(val);
        },
        writeSFixed64Field: function(tag, val) {
            this.writeTag(tag, Pbf.Fixed64);
            this.writeSFixed64(val);
        },
        writeVarintField: function(tag, val) {
            this.writeTag(tag, Pbf.Varint);
            this.writeVarint(val);
        },
        writeSVarintField: function(tag, val) {
            this.writeTag(tag, Pbf.Varint);
            this.writeSVarint(val);
        },
        writeStringField: function(tag, str) {
            this.writeTag(tag, Pbf.Bytes);
            this.writeString(str);
        },
        writeFloatField: function(tag, val) {
            this.writeTag(tag, Pbf.Fixed32);
            this.writeFloat(val);
        },
        writeDoubleField: function(tag, val) {
            this.writeTag(tag, Pbf.Fixed64);
            this.writeDouble(val);
        },
        writeBooleanField: function(tag, val) {
            this.writeVarintField(tag, Boolean(val));
        }
    };

    function readVarintRemainder(l, s, p) {
        var buf = p.buf,
            h, b;

        b = buf[p.pos++]; h  = (b & 0x70) >> 4;  if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 3;  if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);

        throw new Error('Expected varint not more than 10 bytes');
    }

    function readPackedEnd(pbf) {
        return pbf.type === Pbf.Bytes ?
            pbf.readVarint() + pbf.pos : pbf.pos + 1;
    }

    function toNum(low, high, isSigned) {
        if (isSigned) {
            return high * 0x100000000 + (low >>> 0);
        }

        return ((high >>> 0) * 0x100000000) + (low >>> 0);
    }

    function writeBigVarint(val, pbf) {
        var low, high;

        if (val >= 0) {
            low  = (val % 0x100000000) | 0;
            high = (val / 0x100000000) | 0;
        } else {
            low  = ~(-val % 0x100000000);
            high = ~(-val / 0x100000000);

            if (low ^ 0xffffffff) {
                low = (low + 1) | 0;
            } else {
                low = 0;
                high = (high + 1) | 0;
            }
        }

        if (val >= 0x10000000000000000 || val < -0x10000000000000000) {
            throw new Error('Given varint doesn\'t fit into 10 bytes');
        }

        pbf.realloc(10);

        writeBigVarintLow(low, high, pbf);
        writeBigVarintHigh(high, pbf);
    }

    function writeBigVarintLow(low, high, pbf) {
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos]   = low & 0x7f;
    }

    function writeBigVarintHigh(high, pbf) {
        var lsb = (high & 0x07) << 4;

        pbf.buf[pbf.pos++] |= lsb         | ((high >>>= 3) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++]  = high & 0x7f;
    }

    function makeRoomForExtraLength(startPos, len, pbf) {
        var extraLen =
            len <= 0x3fff ? 1 :
            len <= 0x1fffff ? 2 :
            len <= 0xfffffff ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));

        // if 1 byte isn't enough for encoding message length, shift the data to the right
        pbf.realloc(extraLen);
        for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];
    }

    function writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }
    function writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }
    function writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }
    function writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }
    function writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }
    function writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }
    function writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }
    function writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }
    function writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }

    // Buffer code below from https://github.com/feross/buffer, MIT-licensed

    function readUInt32(buf, pos) {
        return ((buf[pos]) |
            (buf[pos + 1] << 8) |
            (buf[pos + 2] << 16)) +
            (buf[pos + 3] * 0x1000000);
    }

    function writeInt32(buf, val, pos) {
        buf[pos] = val;
        buf[pos + 1] = (val >>> 8);
        buf[pos + 2] = (val >>> 16);
        buf[pos + 3] = (val >>> 24);
    }

    function readInt32(buf, pos) {
        return ((buf[pos]) |
            (buf[pos + 1] << 8) |
            (buf[pos + 2] << 16)) +
            (buf[pos + 3] << 24);
    }

    function readUtf8(buf, pos, end) {
        var str = '';
        var i = pos;

        while (i < end) {
            var b0 = buf[i];
            var c = null; // codepoint
            var bytesPerSequence =
                b0 > 0xEF ? 4 :
                b0 > 0xDF ? 3 :
                b0 > 0xBF ? 2 : 1;

            if (i + bytesPerSequence > end) break;

            var b1, b2, b3;

            if (bytesPerSequence === 1) {
                if (b0 < 0x80) {
                    c = b0;
                }
            } else if (bytesPerSequence === 2) {
                b1 = buf[i + 1];
                if ((b1 & 0xC0) === 0x80) {
                    c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);
                    if (c <= 0x7F) {
                        c = null;
                    }
                }
            } else if (bytesPerSequence === 3) {
                b1 = buf[i + 1];
                b2 = buf[i + 2];
                if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {
                    c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);
                    if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {
                        c = null;
                    }
                }
            } else if (bytesPerSequence === 4) {
                b1 = buf[i + 1];
                b2 = buf[i + 2];
                b3 = buf[i + 3];
                if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
                    c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);
                    if (c <= 0xFFFF || c >= 0x110000) {
                        c = null;
                    }
                }
            }

            if (c === null) {
                c = 0xFFFD;
                bytesPerSequence = 1;

            } else if (c > 0xFFFF) {
                c -= 0x10000;
                str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);
                c = 0xDC00 | c & 0x3FF;
            }

            str += String.fromCharCode(c);
            i += bytesPerSequence;
        }

        return str;
    }

    function readUtf8TextDecoder(buf, pos, end) {
        return utf8TextDecoder.decode(buf.subarray(pos, end));
    }

    function writeUtf8(buf, str, pos) {
        for (var i = 0, c, lead; i < str.length; i++) {
            c = str.charCodeAt(i); // code point

            if (c > 0xD7FF && c < 0xE000) {
                if (lead) {
                    if (c < 0xDC00) {
                        buf[pos++] = 0xEF;
                        buf[pos++] = 0xBF;
                        buf[pos++] = 0xBD;
                        lead = c;
                        continue;
                    } else {
                        c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;
                        lead = null;
                    }
                } else {
                    if (c > 0xDBFF || (i + 1 === str.length)) {
                        buf[pos++] = 0xEF;
                        buf[pos++] = 0xBF;
                        buf[pos++] = 0xBD;
                    } else {
                        lead = c;
                    }
                    continue;
                }
            } else if (lead) {
                buf[pos++] = 0xEF;
                buf[pos++] = 0xBF;
                buf[pos++] = 0xBD;
                lead = null;
            }

            if (c < 0x80) {
                buf[pos++] = c;
            } else {
                if (c < 0x800) {
                    buf[pos++] = c >> 0x6 | 0xC0;
                } else {
                    if (c < 0x10000) {
                        buf[pos++] = c >> 0xC | 0xE0;
                    } else {
                        buf[pos++] = c >> 0x12 | 0xF0;
                        buf[pos++] = c >> 0xC & 0x3F | 0x80;
                    }
                    buf[pos++] = c >> 0x6 & 0x3F | 0x80;
                }
                buf[pos++] = c & 0x3F | 0x80;
            }
        }
        return pos;
    }

    /**
     * Decompress and parse an array buffer containing zipped
     * json data and return as a json object.
     *
     * @description Handles array buffers continaing zipped json
     * data.
     *
     * @param {ArrayBuffer} buffer - Array buffer to decompress.
     * @returns {Object} Parsed object.
     */
    function decompress(buffer) {
        const inflated = inflate_1$2(buffer, { to: "string" });
        return JSON.parse(inflated);
    }
    /**
     * Retrieves a resource as an array buffer and returns a promise
     * to the buffer.
     *
     * @description Rejects the promise on request failure.
     *
     * @param {string} url - URL for resource to retrieve.
     * @param {Promise} [abort] - Optional promise for aborting
     * the request through rejection.
     * @returns {Promise<ArrayBuffer>} Promise to the array buffer
     * resource.
     */
    function fetchArrayBuffer(url, abort) {
        const method = "GET";
        const responseType = "arraybuffer";
        return xhrFetch(url, method, responseType, [], null, abort);
    }
    function xhrFetch(url, method, responseType, headers, body, abort) {
        const xhr = new XMLHttpRequest();
        const promise = new Promise((resolve, reject) => {
            xhr.open(method, url, true);
            for (const header of headers) {
                xhr.setRequestHeader(header.name, header.value);
            }
            xhr.responseType = responseType;
            xhr.timeout = 15000;
            xhr.onload = () => {
                var _a;
                if (xhr.status !== 200) {
                    const error = (_a = xhr.response) !== null && _a !== void 0 ? _a : new MapillaryError(`Response status error: ${url}`);
                    reject(error);
                }
                if (!xhr.response) {
                    reject(new MapillaryError(`Response empty: ${url}`));
                }
                resolve(xhr.response);
            };
            xhr.onerror = () => {
                reject(new MapillaryError(`Request error: ${url}`));
            };
            xhr.ontimeout = () => {
                reject(new MapillaryError(`Request timeout: ${url}`));
            };
            xhr.onabort = () => {
                reject(new MapillaryError(`Request aborted: ${url}`));
            };
            xhr.send(method === "POST" ? body : null);
        });
        if (!!abort) {
            abort.catch(() => { xhr.abort(); });
        }
        return promise;
    }
    /**
     * Read the fields of a protobuf array buffer into a mesh
     * object.
     *
     * @param {ArrayBuffer} buffer - Protobuf array buffer
     * to read from.
     * @returns {MeshContract} Mesh object.
     */
    function readMeshPbf(buffer) {
        const pbf$1 = new pbf(buffer);
        const mesh = { faces: [], vertices: [] };
        return pbf$1.readFields(readMeshPbfField, mesh);
    }
    function readMeshPbfField(tag, mesh, pbf) {
        if (tag === 1) {
            mesh.vertices.push(pbf.readFloat());
        }
        else if (tag === 2) {
            mesh.faces.push(pbf.readVarint());
        }
        else {
            console.warn(`Unsupported pbf tag (${tag})`);
        }
    }

    /**
     * @class GeometryProviderBase
     *
     * @classdesc Base class to extend if implementing a geometry
     * provider class.
     *
     * @example
     * ```js
     * class MyGeometryProvider extends GeometryProviderBase {
     *      ...
     * }
     * ```
     */
    class GeometryProviderBase {
        /**
         * Create a new geometry provider base instance.
         */
        constructor() { }
        /**
         * Convert a geodetic bounding box to the the minimum set
         * of cell ids containing the bounding box.
         *
         * @description The bounding box needs
         * to be sufficiently small to be contained in an area with the size
         * of maximally four tiles. Up to nine adjacent tiles may be returned.
         *
         * @param {LngLat} sw - South west corner of bounding box.
         * @param {LngLat} ne - North east corner of bounding box.
         *
         * @returns {Array<string>} Array of cell ids.
         */
        bboxToCellIds(sw, ne) {
            throw new MapillaryError("Not implemented");
        }
        /**
         * Get the cell ids of all adjacent cells.
         *
         * @description In the case of approximately rectangular cells
         * this is typically the eight orthogonally and diagonally adjacent
         * cells.
         *
         * @param {string} cellId - Id of cell.
         * @returns {Array<string>} Array of cell ids. No specific
         * order is guaranteed.
         */
        getAdjacent(cellId) {
            throw new MapillaryError("Not implemented");
        }
        /**
         * Get the vertices of a cell.
         *
         * @description The vertices form an unclosed
         * clockwise polygon in the 2D longitude, latitude
         * space. No assumption on the position of the first
         * vertex relative to the others can be made.
         *
         * @param {string} cellId - Id of cell.
         * @returns {Array<LngLat>} Unclosed clockwise polygon.
         */
        getVertices(cellId) {
            throw new MapillaryError("Not implemented");
        }
        /**
         * Convert geodetic coordinates to a cell id.
         *
         * @param {LngLat} lngLat - Longitude, latitude to convert.
         * @returns {string} Cell id for the longitude, latitude.
         */
        lngLatToCellId(lngLat) {
            throw new MapillaryError("Not implemented");
        }
        /** @ignore */
        _approxBboxToCellIds(sw, ne) {
            if (ne.lat <= sw.lat || ne.lng <= sw.lng) {
                throw new MapillaryError("North east needs to be top right of south west");
            }
            const centerLat = (sw.lat + ne.lat) / 2;
            const centerLng = (sw.lng + ne.lng) / 2;
            const enu = geodeticToEnu(ne.lng, ne.lat, 0, centerLng, centerLat, 0);
            const threshold = Math.max(enu[0], enu[1]);
            return this._lngLatToCellIds({ lat: centerLat, lng: centerLng }, threshold);
        }
        /** @ignore */
        _enuToGeodetic(point, reference) {
            const [lng, lat] = enuToGeodetic(point[0], point[1], point[2], reference.lng, reference.lat, 0);
            return { lat, lng };
        }
        /** @ignore */
        _getLngLatBoundingBoxCorners(lngLat, threshold) {
            return [
                [-threshold, threshold, 0],
                [threshold, threshold, 0],
                [threshold, -threshold, 0],
                [-threshold, -threshold, 0],
            ].map((point) => {
                return this._enuToGeodetic(point, lngLat);
            });
        }
        /**
         * Convert a geodetic square to cell ids.
         *
         * The square is specified as a longitude, latitude
         * and a threshold from the position using Manhattan distance.
         *
         * @param {LngLat} lngLat - Longitude, latitude.
         * @param {number} threshold - Threshold of the conversion in meters.
         *
         * @returns {Array<string>} Array of cell ids reachable within
         * the threshold.
         *
         * @ignore
         */
        _lngLatToCellIds(lngLat, threshold) {
            const cellId = this.lngLatToCellId(lngLat);
            const bboxCorners = this._getLngLatBoundingBoxCorners(lngLat, threshold);
            for (const corner of bboxCorners) {
                const cid = this.lngLatToCellId(corner);
                if (cid !== cellId) {
                    return [cellId, ...this.getAdjacent(cellId)];
                }
            }
            return [cellId];
        }
    }

    /**
     * @class DataProviderBase
     *
     * @classdesc Base class to extend if implementing a data provider
     * class.
     *
     * @fires datacreate
     *
     * @example
     * ```js
     * class MyDataProvider extends DataProviderBase {
     *   constructor() {
     *     super(new S2GeometryProvider());
     *   }
     *   ...
     * }
     * ```
     */
    class DataProviderBase extends EventEmitter {
        /**
         * Create a new data provider base instance.
         *
         * @param {GeometryProviderBase} geometry - Geometry
         * provider instance.
         */
        constructor(_geometry) {
            super();
            this._geometry = _geometry;
            if (!(this._geometry instanceof GeometryProviderBase)) {
                throw new MapillaryError("The data provider requires a geometry provider base instance.");
            }
        }
        /**
         * Get geometry property.
         *
         * @returns {GeometryProviderBase} Geometry provider instance.
         */
        get geometry() {
            return this._geometry;
        }
        fire(type, event) {
            super.fire(type, event);
        }
        /**
         * Get core images in a geometry cell.
         *
         * @param {string} cellId - The id of the geometry cell.
         * @returns {Promise<CoreImagesContract>} Promise to
         * the core images of the requested geometry cell id.
         * @throws Rejects the promise on errors.
         */
        getCoreImages(cellId) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get a cluster reconstruction.
         *
         * @param {string} url - URL for the cluster reconstruction
         * to retrieve.
         * @param {Promise} [abort] - Optional promise for aborting
         * the request through rejection.
         * @returns {Promise<ClusterContract>} Promise to the
         * cluster reconstruction.
         * @throws Rejects the promise on errors.
         */
        getCluster(url, abort) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get spatial images.
         *
         * @param {Array<string>} imageIds - The ids for the
         * images to retrieve.
         * @returns {Promise<SpatialImagesContract>} Promise to
         * the spatial images of the requested image ids.
         * @throws Rejects the promise on errors.
         */
        getSpatialImages(imageIds) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get complete images.
         *
         * @param {Array<string>} imageIds - The ids for the
         * images to retrieve.
         * @returns {Promise<ImagesContract>} Promise to the images of the
         * requested image ids.
         * @throws Rejects the promise on errors.
         */
        getImages(imageIds) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get an image as an array buffer.
         *
         * @param {string} url - URL for image to retrieve.
         * @param {Promise<void>} [abort] - Optional promise for aborting
         * the request through rejection.
         * @returns {Promise<ArrayBuffer>} Promise to the array
         * buffer containing the image.
         * @throws Rejects the promise on errors.
         */
        getImageBuffer(url, abort) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get image tiles urls for a tile level.
         *
         * @param {ImageTilesRequestContract} tiles - Tiles to request
         * @returns {Promise<ImageTilesContract>} Promise to the
         * image tiles response contract
         *
         * @throws Rejects the promise on errors.
         *
         * @example
         * ```js
         * var tileRequest = { imageId: 'image-id', z: 12 };
         * provider.getImageTiles(tileRequest)
         *   .then((response) => console.log(response));
         * ```
         */
        getImageTiles(tiles) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get a mesh.
         *
         * @param {string} url - URL for mesh to retrieve.
         * @param {Promise<void>} [abort] - Optional promise for aborting
         * the request through rejection.
         * @returns {Promise<MeshContract>} Promise to the mesh.
         * @throws Rejects the promise on errors.
         */
        getMesh(url, abort) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        /**
         * Get sequence.
         *
         * @param {Array<string>} sequenceId - The id for the
         * sequence to retrieve.
         * @returns {Promise} Promise to the sequences of the
         * requested image ids.
         * @throws Rejects the promise on errors.
         */
        getSequence(sequenceId) {
            return Promise.reject(new MapillaryError("Not implemented"));
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Set an access token for authenticated API requests of
         * protected resources.
         *
         * @param {string} [accessToken] accessToken - User access
         * token or client access token.
         */
        setAccessToken(accessToken) {
            throw new MapillaryError("Not implemented");
        }
    }

    /*
     Copyright 2013 Daniel Wirtz <dcode@dcode.io>
     Copyright 2009 The Closure Library Authors. All Rights Reserved.

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS-IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
     */

    var long = createCommonjsModule(function (module) {
    /**
     * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
     * Released under the Apache License, Version 2.0
     * see: https://github.com/dcodeIO/long.js for details
     */
    (function(global, factory) {

        /* AMD */ if (typeof commonjsRequire === 'function' && 'object' === "object" && module && module["exports"])
            module["exports"] = factory();
        /* Global */ else
            (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory();

    })(commonjsGlobal, function() {

        /**
         * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
         *  See the from* functions below for more convenient ways of constructing Longs.
         * @exports Long
         * @class A Long class for representing a 64 bit two's-complement integer value.
         * @param {number} low The low (signed) 32 bits of the long
         * @param {number} high The high (signed) 32 bits of the long
         * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
         * @constructor
         */
        function Long(low, high, unsigned) {

            /**
             * The low 32 bits as a signed value.
             * @type {number}
             */
            this.low = low | 0;

            /**
             * The high 32 bits as a signed value.
             * @type {number}
             */
            this.high = high | 0;

            /**
             * Whether unsigned or not.
             * @type {boolean}
             */
            this.unsigned = !!unsigned;
        }

        // The internal representation of a long is the two given signed, 32-bit values.
        // We use 32-bit pieces because these are the size of integers on which
        // Javascript performs bit-operations.  For operations like addition and
        // multiplication, we split each number into 16 bit pieces, which can easily be
        // multiplied within Javascript's floating-point representation without overflow
        // or change in sign.
        //
        // In the algorithms below, we frequently reduce the negative case to the
        // positive case by negating the input(s) and then post-processing the result.
        // Note that we must ALWAYS check specially whether those values are MIN_VALUE
        // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
        // a positive number, it overflows back into a negative).  Not handling this
        // case would often result in infinite recursion.
        //
        // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*
        // methods on which they depend.

        /**
         * An indicator used to reliably determine if an object is a Long or not.
         * @type {boolean}
         * @const
         * @private
         */
        Long.prototype.__isLong__;

        Object.defineProperty(Long.prototype, "__isLong__", {
            value: true,
            enumerable: false,
            configurable: false
        });

        /**
         * @function
         * @param {*} obj Object
         * @returns {boolean}
         * @inner
         */
        function isLong(obj) {
            return (obj && obj["__isLong__"]) === true;
        }

        /**
         * Tests if the specified object is a Long.
         * @function
         * @param {*} obj Object
         * @returns {boolean}
         */
        Long.isLong = isLong;

        /**
         * A cache of the Long representations of small integer values.
         * @type {!Object}
         * @inner
         */
        var INT_CACHE = {};

        /**
         * A cache of the Long representations of small unsigned integer values.
         * @type {!Object}
         * @inner
         */
        var UINT_CACHE = {};

        /**
         * @param {number} value
         * @param {boolean=} unsigned
         * @returns {!Long}
         * @inner
         */
        function fromInt(value, unsigned) {
            var obj, cachedObj, cache;
            if (unsigned) {
                value >>>= 0;
                if (cache = (0 <= value && value < 256)) {
                    cachedObj = UINT_CACHE[value];
                    if (cachedObj)
                        return cachedObj;
                }
                obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);
                if (cache)
                    UINT_CACHE[value] = obj;
                return obj;
            } else {
                value |= 0;
                if (cache = (-128 <= value && value < 128)) {
                    cachedObj = INT_CACHE[value];
                    if (cachedObj)
                        return cachedObj;
                }
                obj = fromBits(value, value < 0 ? -1 : 0, false);
                if (cache)
                    INT_CACHE[value] = obj;
                return obj;
            }
        }

        /**
         * Returns a Long representing the given 32 bit integer value.
         * @function
         * @param {number} value The 32 bit integer in question
         * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
         * @returns {!Long} The corresponding Long value
         */
        Long.fromInt = fromInt;

        /**
         * @param {number} value
         * @param {boolean=} unsigned
         * @returns {!Long}
         * @inner
         */
        function fromNumber(value, unsigned) {
            if (isNaN(value) || !isFinite(value))
                return unsigned ? UZERO : ZERO;
            if (unsigned) {
                if (value < 0)
                    return UZERO;
                if (value >= TWO_PWR_64_DBL)
                    return MAX_UNSIGNED_VALUE;
            } else {
                if (value <= -TWO_PWR_63_DBL)
                    return MIN_VALUE;
                if (value + 1 >= TWO_PWR_63_DBL)
                    return MAX_VALUE;
            }
            if (value < 0)
                return fromNumber(-value, unsigned).neg();
            return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);
        }

        /**
         * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
         * @function
         * @param {number} value The number in question
         * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
         * @returns {!Long} The corresponding Long value
         */
        Long.fromNumber = fromNumber;

        /**
         * @param {number} lowBits
         * @param {number} highBits
         * @param {boolean=} unsigned
         * @returns {!Long}
         * @inner
         */
        function fromBits(lowBits, highBits, unsigned) {
            return new Long(lowBits, highBits, unsigned);
        }

        /**
         * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
         *  assumed to use 32 bits.
         * @function
         * @param {number} lowBits The low 32 bits
         * @param {number} highBits The high 32 bits
         * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
         * @returns {!Long} The corresponding Long value
         */
        Long.fromBits = fromBits;

        /**
         * @function
         * @param {number} base
         * @param {number} exponent
         * @returns {number}
         * @inner
         */
        var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)

        /**
         * @param {string} str
         * @param {(boolean|number)=} unsigned
         * @param {number=} radix
         * @returns {!Long}
         * @inner
         */
        function fromString(str, unsigned, radix) {
            if (str.length === 0)
                throw Error('empty string');
            if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
                return ZERO;
            if (typeof unsigned === 'number') {
                // For goog.math.long compatibility
                radix = unsigned,
                unsigned = false;
            } else {
                unsigned = !! unsigned;
            }
            radix = radix || 10;
            if (radix < 2 || 36 < radix)
                throw RangeError('radix');

            var p;
            if ((p = str.indexOf('-')) > 0)
                throw Error('interior hyphen');
            else if (p === 0) {
                return fromString(str.substring(1), unsigned, radix).neg();
            }

            // Do several (8) digits each time through the loop, so as to
            // minimize the calls to the very expensive emulated div.
            var radixToPower = fromNumber(pow_dbl(radix, 8));

            var result = ZERO;
            for (var i = 0; i < str.length; i += 8) {
                var size = Math.min(8, str.length - i),
                    value = parseInt(str.substring(i, i + size), radix);
                if (size < 8) {
                    var power = fromNumber(pow_dbl(radix, size));
                    result = result.mul(power).add(fromNumber(value));
                } else {
                    result = result.mul(radixToPower);
                    result = result.add(fromNumber(value));
                }
            }
            result.unsigned = unsigned;
            return result;
        }

        /**
         * Returns a Long representation of the given string, written using the specified radix.
         * @function
         * @param {string} str The textual representation of the Long
         * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed
         * @param {number=} radix The radix in which the text is written (2-36), defaults to 10
         * @returns {!Long} The corresponding Long value
         */
        Long.fromString = fromString;

        /**
         * @function
         * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val
         * @returns {!Long}
         * @inner
         */
        function fromValue(val) {
            if (val /* is compatible */ instanceof Long)
                return val;
            if (typeof val === 'number')
                return fromNumber(val);
            if (typeof val === 'string')
                return fromString(val);
            // Throws for non-objects, converts non-instanceof Long:
            return fromBits(val.low, val.high, val.unsigned);
        }

        /**
         * Converts the specified value to a Long.
         * @function
         * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value
         * @returns {!Long}
         */
        Long.fromValue = fromValue;

        // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be
        // no runtime penalty for these.

        /**
         * @type {number}
         * @const
         * @inner
         */
        var TWO_PWR_16_DBL = 1 << 16;

        /**
         * @type {number}
         * @const
         * @inner
         */
        var TWO_PWR_24_DBL = 1 << 24;

        /**
         * @type {number}
         * @const
         * @inner
         */
        var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;

        /**
         * @type {number}
         * @const
         * @inner
         */
        var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;

        /**
         * @type {number}
         * @const
         * @inner
         */
        var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;

        /**
         * @type {!Long}
         * @const
         * @inner
         */
        var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);

        /**
         * @type {!Long}
         * @inner
         */
        var ZERO = fromInt(0);

        /**
         * Signed zero.
         * @type {!Long}
         */
        Long.ZERO = ZERO;

        /**
         * @type {!Long}
         * @inner
         */
        var UZERO = fromInt(0, true);

        /**
         * Unsigned zero.
         * @type {!Long}
         */
        Long.UZERO = UZERO;

        /**
         * @type {!Long}
         * @inner
         */
        var ONE = fromInt(1);

        /**
         * Signed one.
         * @type {!Long}
         */
        Long.ONE = ONE;

        /**
         * @type {!Long}
         * @inner
         */
        var UONE = fromInt(1, true);

        /**
         * Unsigned one.
         * @type {!Long}
         */
        Long.UONE = UONE;

        /**
         * @type {!Long}
         * @inner
         */
        var NEG_ONE = fromInt(-1);

        /**
         * Signed negative one.
         * @type {!Long}
         */
        Long.NEG_ONE = NEG_ONE;

        /**
         * @type {!Long}
         * @inner
         */
        var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);

        /**
         * Maximum signed value.
         * @type {!Long}
         */
        Long.MAX_VALUE = MAX_VALUE;

        /**
         * @type {!Long}
         * @inner
         */
        var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);

        /**
         * Maximum unsigned value.
         * @type {!Long}
         */
        Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;

        /**
         * @type {!Long}
         * @inner
         */
        var MIN_VALUE = fromBits(0, 0x80000000|0, false);

        /**
         * Minimum signed value.
         * @type {!Long}
         */
        Long.MIN_VALUE = MIN_VALUE;

        /**
         * @alias Long.prototype
         * @inner
         */
        var LongPrototype = Long.prototype;

        /**
         * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
         * @returns {number}
         */
        LongPrototype.toInt = function toInt() {
            return this.unsigned ? this.low >>> 0 : this.low;
        };

        /**
         * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
         * @returns {number}
         */
        LongPrototype.toNumber = function toNumber() {
            if (this.unsigned)
                return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);
            return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
        };

        /**
         * Converts the Long to a string written in the specified radix.
         * @param {number=} radix Radix (2-36), defaults to 10
         * @returns {string}
         * @override
         * @throws {RangeError} If `radix` is out of range
         */
        LongPrototype.toString = function toString(radix) {
            radix = radix || 10;
            if (radix < 2 || 36 < radix)
                throw RangeError('radix');
            if (this.isZero())
                return '0';
            if (this.isNegative()) { // Unsigned Longs are never negative
                if (this.eq(MIN_VALUE)) {
                    // We need to change the Long value before it can be negated, so we remove
                    // the bottom-most digit in this base and then recurse to do the rest.
                    var radixLong = fromNumber(radix),
                        div = this.div(radixLong),
                        rem1 = div.mul(radixLong).sub(this);
                    return div.toString(radix) + rem1.toInt().toString(radix);
                } else
                    return '-' + this.neg().toString(radix);
            }

            // Do several (6) digits each time through the loop, so as to
            // minimize the calls to the very expensive emulated div.
            var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),
                rem = this;
            var result = '';
            while (true) {
                var remDiv = rem.div(radixToPower),
                    intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,
                    digits = intval.toString(radix);
                rem = remDiv;
                if (rem.isZero())
                    return digits + result;
                else {
                    while (digits.length < 6)
                        digits = '0' + digits;
                    result = '' + digits + result;
                }
            }
        };

        /**
         * Gets the high 32 bits as a signed integer.
         * @returns {number} Signed high bits
         */
        LongPrototype.getHighBits = function getHighBits() {
            return this.high;
        };

        /**
         * Gets the high 32 bits as an unsigned integer.
         * @returns {number} Unsigned high bits
         */
        LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
            return this.high >>> 0;
        };

        /**
         * Gets the low 32 bits as a signed integer.
         * @returns {number} Signed low bits
         */
        LongPrototype.getLowBits = function getLowBits() {
            return this.low;
        };

        /**
         * Gets the low 32 bits as an unsigned integer.
         * @returns {number} Unsigned low bits
         */
        LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
            return this.low >>> 0;
        };

        /**
         * Gets the number of bits needed to represent the absolute value of this Long.
         * @returns {number}
         */
        LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
            if (this.isNegative()) // Unsigned Longs are never negative
                return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
            var val = this.high != 0 ? this.high : this.low;
            for (var bit = 31; bit > 0; bit--)
                if ((val & (1 << bit)) != 0)
                    break;
            return this.high != 0 ? bit + 33 : bit + 1;
        };

        /**
         * Tests if this Long's value equals zero.
         * @returns {boolean}
         */
        LongPrototype.isZero = function isZero() {
            return this.high === 0 && this.low === 0;
        };

        /**
         * Tests if this Long's value is negative.
         * @returns {boolean}
         */
        LongPrototype.isNegative = function isNegative() {
            return !this.unsigned && this.high < 0;
        };

        /**
         * Tests if this Long's value is positive.
         * @returns {boolean}
         */
        LongPrototype.isPositive = function isPositive() {
            return this.unsigned || this.high >= 0;
        };

        /**
         * Tests if this Long's value is odd.
         * @returns {boolean}
         */
        LongPrototype.isOdd = function isOdd() {
            return (this.low & 1) === 1;
        };

        /**
         * Tests if this Long's value is even.
         * @returns {boolean}
         */
        LongPrototype.isEven = function isEven() {
            return (this.low & 1) === 0;
        };

        /**
         * Tests if this Long's value equals the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.equals = function equals(other) {
            if (!isLong(other))
                other = fromValue(other);
            if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)
                return false;
            return this.high === other.high && this.low === other.low;
        };

        /**
         * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.eq = LongPrototype.equals;

        /**
         * Tests if this Long's value differs from the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.notEquals = function notEquals(other) {
            return !this.eq(/* validates */ other);
        };

        /**
         * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.neq = LongPrototype.notEquals;

        /**
         * Tests if this Long's value is less than the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.lessThan = function lessThan(other) {
            return this.comp(/* validates */ other) < 0;
        };

        /**
         * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.lt = LongPrototype.lessThan;

        /**
         * Tests if this Long's value is less than or equal the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
            return this.comp(/* validates */ other) <= 0;
        };

        /**
         * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.lte = LongPrototype.lessThanOrEqual;

        /**
         * Tests if this Long's value is greater than the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.greaterThan = function greaterThan(other) {
            return this.comp(/* validates */ other) > 0;
        };

        /**
         * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.gt = LongPrototype.greaterThan;

        /**
         * Tests if this Long's value is greater than or equal the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
            return this.comp(/* validates */ other) >= 0;
        };

        /**
         * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {boolean}
         */
        LongPrototype.gte = LongPrototype.greaterThanOrEqual;

        /**
         * Compares this Long's value with the specified's.
         * @param {!Long|number|string} other Other value
         * @returns {number} 0 if they are the same, 1 if the this is greater and -1
         *  if the given one is greater
         */
        LongPrototype.compare = function compare(other) {
            if (!isLong(other))
                other = fromValue(other);
            if (this.eq(other))
                return 0;
            var thisNeg = this.isNegative(),
                otherNeg = other.isNegative();
            if (thisNeg && !otherNeg)
                return -1;
            if (!thisNeg && otherNeg)
                return 1;
            // At this point the sign bits are the same
            if (!this.unsigned)
                return this.sub(other).isNegative() ? -1 : 1;
            // Both are positive if at least one is unsigned
            return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;
        };

        /**
         * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.
         * @function
         * @param {!Long|number|string} other Other value
         * @returns {number} 0 if they are the same, 1 if the this is greater and -1
         *  if the given one is greater
         */
        LongPrototype.comp = LongPrototype.compare;

        /**
         * Negates this Long's value.
         * @returns {!Long} Negated Long
         */
        LongPrototype.negate = function negate() {
            if (!this.unsigned && this.eq(MIN_VALUE))
                return MIN_VALUE;
            return this.not().add(ONE);
        };

        /**
         * Negates this Long's value. This is an alias of {@link Long#negate}.
         * @function
         * @returns {!Long} Negated Long
         */
        LongPrototype.neg = LongPrototype.negate;

        /**
         * Returns the sum of this and the specified Long.
         * @param {!Long|number|string} addend Addend
         * @returns {!Long} Sum
         */
        LongPrototype.add = function add(addend) {
            if (!isLong(addend))
                addend = fromValue(addend);

            // Divide each number into 4 chunks of 16 bits, and then sum the chunks.

            var a48 = this.high >>> 16;
            var a32 = this.high & 0xFFFF;
            var a16 = this.low >>> 16;
            var a00 = this.low & 0xFFFF;

            var b48 = addend.high >>> 16;
            var b32 = addend.high & 0xFFFF;
            var b16 = addend.low >>> 16;
            var b00 = addend.low & 0xFFFF;

            var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
            c00 += a00 + b00;
            c16 += c00 >>> 16;
            c00 &= 0xFFFF;
            c16 += a16 + b16;
            c32 += c16 >>> 16;
            c16 &= 0xFFFF;
            c32 += a32 + b32;
            c48 += c32 >>> 16;
            c32 &= 0xFFFF;
            c48 += a48 + b48;
            c48 &= 0xFFFF;
            return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
        };

        /**
         * Returns the difference of this and the specified Long.
         * @param {!Long|number|string} subtrahend Subtrahend
         * @returns {!Long} Difference
         */
        LongPrototype.subtract = function subtract(subtrahend) {
            if (!isLong(subtrahend))
                subtrahend = fromValue(subtrahend);
            return this.add(subtrahend.neg());
        };

        /**
         * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.
         * @function
         * @param {!Long|number|string} subtrahend Subtrahend
         * @returns {!Long} Difference
         */
        LongPrototype.sub = LongPrototype.subtract;

        /**
         * Returns the product of this and the specified Long.
         * @param {!Long|number|string} multiplier Multiplier
         * @returns {!Long} Product
         */
        LongPrototype.multiply = function multiply(multiplier) {
            if (this.isZero())
                return ZERO;
            if (!isLong(multiplier))
                multiplier = fromValue(multiplier);
            if (multiplier.isZero())
                return ZERO;
            if (this.eq(MIN_VALUE))
                return multiplier.isOdd() ? MIN_VALUE : ZERO;
            if (multiplier.eq(MIN_VALUE))
                return this.isOdd() ? MIN_VALUE : ZERO;

            if (this.isNegative()) {
                if (multiplier.isNegative())
                    return this.neg().mul(multiplier.neg());
                else
                    return this.neg().mul(multiplier).neg();
            } else if (multiplier.isNegative())
                return this.mul(multiplier.neg()).neg();

            // If both longs are small, use float multiplication
            if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
                return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);

            // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
            // We can skip products that would overflow.

            var a48 = this.high >>> 16;
            var a32 = this.high & 0xFFFF;
            var a16 = this.low >>> 16;
            var a00 = this.low & 0xFFFF;

            var b48 = multiplier.high >>> 16;
            var b32 = multiplier.high & 0xFFFF;
            var b16 = multiplier.low >>> 16;
            var b00 = multiplier.low & 0xFFFF;

            var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
            c00 += a00 * b00;
            c16 += c00 >>> 16;
            c00 &= 0xFFFF;
            c16 += a16 * b00;
            c32 += c16 >>> 16;
            c16 &= 0xFFFF;
            c16 += a00 * b16;
            c32 += c16 >>> 16;
            c16 &= 0xFFFF;
            c32 += a32 * b00;
            c48 += c32 >>> 16;
            c32 &= 0xFFFF;
            c32 += a16 * b16;
            c48 += c32 >>> 16;
            c32 &= 0xFFFF;
            c32 += a00 * b32;
            c48 += c32 >>> 16;
            c32 &= 0xFFFF;
            c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
            c48 &= 0xFFFF;
            return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
        };

        /**
         * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.
         * @function
         * @param {!Long|number|string} multiplier Multiplier
         * @returns {!Long} Product
         */
        LongPrototype.mul = LongPrototype.multiply;

        /**
         * Returns this Long divided by the specified. The result is signed if this Long is signed or
         *  unsigned if this Long is unsigned.
         * @param {!Long|number|string} divisor Divisor
         * @returns {!Long} Quotient
         */
        LongPrototype.divide = function divide(divisor) {
            if (!isLong(divisor))
                divisor = fromValue(divisor);
            if (divisor.isZero())
                throw Error('division by zero');
            if (this.isZero())
                return this.unsigned ? UZERO : ZERO;
            var approx, rem, res;
            if (!this.unsigned) {
                // This section is only relevant for signed longs and is derived from the
                // closure library as a whole.
                if (this.eq(MIN_VALUE)) {
                    if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
                        return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE
                    else if (divisor.eq(MIN_VALUE))
                        return ONE;
                    else {
                        // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
                        var halfThis = this.shr(1);
                        approx = halfThis.div(divisor).shl(1);
                        if (approx.eq(ZERO)) {
                            return divisor.isNegative() ? ONE : NEG_ONE;
                        } else {
                            rem = this.sub(divisor.mul(approx));
                            res = approx.add(rem.div(divisor));
                            return res;
                        }
                    }
                } else if (divisor.eq(MIN_VALUE))
                    return this.unsigned ? UZERO : ZERO;
                if (this.isNegative()) {
                    if (divisor.isNegative())
                        return this.neg().div(divisor.neg());
                    return this.neg().div(divisor).neg();
                } else if (divisor.isNegative())
                    return this.div(divisor.neg()).neg();
                res = ZERO;
            } else {
                // The algorithm below has not been made for unsigned longs. It's therefore
                // required to take special care of the MSB prior to running it.
                if (!divisor.unsigned)
                    divisor = divisor.toUnsigned();
                if (divisor.gt(this))
                    return UZERO;
                if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true
                    return UONE;
                res = UZERO;
            }

            // Repeat the following until the remainder is less than other:  find a
            // floating-point that approximates remainder / other *from below*, add this
            // into the result, and subtract it from the remainder.  It is critical that
            // the approximate value is less than or equal to the real value so that the
            // remainder never becomes negative.
            rem = this;
            while (rem.gte(divisor)) {
                // Approximate the result of division. This may be a little greater or
                // smaller than the actual value.
                approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));

                // We will tweak the approximate result by changing it in the 48-th digit or
                // the smallest non-fractional digit, whichever is larger.
                var log2 = Math.ceil(Math.log(approx) / Math.LN2),
                    delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),

                // Decrease the approximation until it is smaller than the remainder.  Note
                // that if it is too large, the product overflows and is negative.
                    approxRes = fromNumber(approx),
                    approxRem = approxRes.mul(divisor);
                while (approxRem.isNegative() || approxRem.gt(rem)) {
                    approx -= delta;
                    approxRes = fromNumber(approx, this.unsigned);
                    approxRem = approxRes.mul(divisor);
                }

                // We know the answer can't be zero... and actually, zero would cause
                // infinite recursion since we would make no progress.
                if (approxRes.isZero())
                    approxRes = ONE;

                res = res.add(approxRes);
                rem = rem.sub(approxRem);
            }
            return res;
        };

        /**
         * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.
         * @function
         * @param {!Long|number|string} divisor Divisor
         * @returns {!Long} Quotient
         */
        LongPrototype.div = LongPrototype.divide;

        /**
         * Returns this Long modulo the specified.
         * @param {!Long|number|string} divisor Divisor
         * @returns {!Long} Remainder
         */
        LongPrototype.modulo = function modulo(divisor) {
            if (!isLong(divisor))
                divisor = fromValue(divisor);
            return this.sub(this.div(divisor).mul(divisor));
        };

        /**
         * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
         * @function
         * @param {!Long|number|string} divisor Divisor
         * @returns {!Long} Remainder
         */
        LongPrototype.mod = LongPrototype.modulo;

        /**
         * Returns the bitwise NOT of this Long.
         * @returns {!Long}
         */
        LongPrototype.not = function not() {
            return fromBits(~this.low, ~this.high, this.unsigned);
        };

        /**
         * Returns the bitwise AND of this Long and the specified.
         * @param {!Long|number|string} other Other Long
         * @returns {!Long}
         */
        LongPrototype.and = function and(other) {
            if (!isLong(other))
                other = fromValue(other);
            return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
        };

        /**
         * Returns the bitwise OR of this Long and the specified.
         * @param {!Long|number|string} other Other Long
         * @returns {!Long}
         */
        LongPrototype.or = function or(other) {
            if (!isLong(other))
                other = fromValue(other);
            return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
        };

        /**
         * Returns the bitwise XOR of this Long and the given one.
         * @param {!Long|number|string} other Other Long
         * @returns {!Long}
         */
        LongPrototype.xor = function xor(other) {
            if (!isLong(other))
                other = fromValue(other);
            return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
        };

        /**
         * Returns this Long with bits shifted to the left by the given amount.
         * @param {number|!Long} numBits Number of bits
         * @returns {!Long} Shifted Long
         */
        LongPrototype.shiftLeft = function shiftLeft(numBits) {
            if (isLong(numBits))
                numBits = numBits.toInt();
            if ((numBits &= 63) === 0)
                return this;
            else if (numBits < 32)
                return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);
            else
                return fromBits(0, this.low << (numBits - 32), this.unsigned);
        };

        /**
         * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.
         * @function
         * @param {number|!Long} numBits Number of bits
         * @returns {!Long} Shifted Long
         */
        LongPrototype.shl = LongPrototype.shiftLeft;

        /**
         * Returns this Long with bits arithmetically shifted to the right by the given amount.
         * @param {number|!Long} numBits Number of bits
         * @returns {!Long} Shifted Long
         */
        LongPrototype.shiftRight = function shiftRight(numBits) {
            if (isLong(numBits))
                numBits = numBits.toInt();
            if ((numBits &= 63) === 0)
                return this;
            else if (numBits < 32)
                return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);
            else
                return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);
        };

        /**
         * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.
         * @function
         * @param {number|!Long} numBits Number of bits
         * @returns {!Long} Shifted Long
         */
        LongPrototype.shr = LongPrototype.shiftRight;

        /**
         * Returns this Long with bits logically shifted to the right by the given amount.
         * @param {number|!Long} numBits Number of bits
         * @returns {!Long} Shifted Long
         */
        LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
            if (isLong(numBits))
                numBits = numBits.toInt();
            numBits &= 63;
            if (numBits === 0)
                return this;
            else {
                var high = this.high;
                if (numBits < 32) {
                    var low = this.low;
                    return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);
                } else if (numBits === 32)
                    return fromBits(high, 0, this.unsigned);
                else
                    return fromBits(high >>> (numBits - 32), 0, this.unsigned);
            }
        };

        /**
         * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
         * @function
         * @param {number|!Long} numBits Number of bits
         * @returns {!Long} Shifted Long
         */
        LongPrototype.shru = LongPrototype.shiftRightUnsigned;

        /**
         * Converts this Long to signed.
         * @returns {!Long} Signed long
         */
        LongPrototype.toSigned = function toSigned() {
            if (!this.unsigned)
                return this;
            return fromBits(this.low, this.high, false);
        };

        /**
         * Converts this Long to unsigned.
         * @returns {!Long} Unsigned long
         */
        LongPrototype.toUnsigned = function toUnsigned() {
            if (this.unsigned)
                return this;
            return fromBits(this.low, this.high, true);
        };

        /**
         * Converts this Long to its byte representation.
         * @param {boolean=} le Whether little or big endian, defaults to big endian
         * @returns {!Array.<number>} Byte representation
         */
        LongPrototype.toBytes = function(le) {
            return le ? this.toBytesLE() : this.toBytesBE();
        };

        /**
         * Converts this Long to its little endian byte representation.
         * @returns {!Array.<number>} Little endian byte representation
         */
        LongPrototype.toBytesLE = function() {
            var hi = this.high,
                lo = this.low;
            return [
                 lo         & 0xff,
                (lo >>>  8) & 0xff,
                (lo >>> 16) & 0xff,
                (lo >>> 24) & 0xff,
                 hi         & 0xff,
                (hi >>>  8) & 0xff,
                (hi >>> 16) & 0xff,
                (hi >>> 24) & 0xff
            ];
        };

        /**
         * Converts this Long to its big endian byte representation.
         * @returns {!Array.<number>} Big endian byte representation
         */
        LongPrototype.toBytesBE = function() {
            var hi = this.high,
                lo = this.low;
            return [
                (hi >>> 24) & 0xff,
                (hi >>> 16) & 0xff,
                (hi >>>  8) & 0xff,
                 hi         & 0xff,
                (lo >>> 24) & 0xff,
                (lo >>> 16) & 0xff,
                (lo >>>  8) & 0xff,
                 lo         & 0xff
            ];
        };

        return Long;
    });
    });

    var s2geometry = createCommonjsModule(function (module) {
    /// S2 Geometry functions
    // the regional scoreboard is based on a level 6 S2 Cell
    // - https://docs.google.com/presentation/d/1Hl4KapfAENAOf4gv-pSngKwvS_jwNVHRPZTTDzXXn6Q/view?pli=1#slide=id.i22
    // at the time of writing there's no actual API for the intel map to retrieve scoreboard data,
    // but it's still useful to plot the score cells on the intel map


    // the S2 geometry is based on projecting the earth sphere onto a cube, with some scaling of face coordinates to
    // keep things close to approximate equal area for adjacent cells
    // to convert a lat,lng into a cell id:
    // - convert lat,lng to x,y,z
    // - convert x,y,z into face,u,v
    // - u,v scaled to s,t with quadratic formula
    // - s,t converted to integer i,j offsets
    // - i,j converted to a position along a Hubbert space-filling curve
    // - combine face,position to get the cell id

    //NOTE: compared to the google S2 geometry library, we vary from their code in the following ways
    // - cell IDs: they combine face and the hilbert curve position into a single 64 bit number. this gives efficient space
    //             and speed. javascript doesn't have appropriate data types, and speed is not cricical, so we use
    //             as [face,[bitpair,bitpair,...]] instead
    // - i,j: they always use 30 bits, adjusting as needed. we use 0 to (1<<level)-1 instead
    //        (so GetSizeIJ for a cell is always 1)

    (function (exports) {

    var S2 = exports.S2 = { L: {} };

    S2.L.LatLng = function (/*Number*/ rawLat, /*Number*/ rawLng, /*Boolean*/ noWrap) {
      var lat = parseFloat(rawLat, 10);
      var lng = parseFloat(rawLng, 10);

      if (isNaN(lat) || isNaN(lng)) {
        throw new Error('Invalid LatLng object: (' + rawLat + ', ' + rawLng + ')');
      }

      if (noWrap !== true) {
        lat = Math.max(Math.min(lat, 90), -90);                 // clamp latitude into -90..90
        lng = (lng + 180) % 360 + ((lng < -180 || lng === 180) ? 180 : -180);   // wrap longtitude into -180..180
      }

      return { lat: lat, lng: lng };
    };

    S2.L.LatLng.DEG_TO_RAD = Math.PI / 180;
    S2.L.LatLng.RAD_TO_DEG = 180 / Math.PI;

    /*
    S2.LatLngToXYZ = function(latLng) {
      // http://stackoverflow.com/questions/8981943/lat-long-to-x-y-z-position-in-js-not-working
      var lat = latLng.lat;
      var lon = latLng.lng;
      var DEG_TO_RAD = Math.PI / 180.0;

      var phi = lat * DEG_TO_RAD;
      var theta = lon * DEG_TO_RAD;

      var cosLat = Math.cos(phi);
      var sinLat = Math.sin(phi);
      var cosLon = Math.cos(theta);
      var sinLon = Math.sin(theta);
      var rad = 500.0;

      return [
        rad * cosLat * cosLon
      , rad * cosLat * sinLon
      , rad * sinLat
      ];
    };
    */
    S2.LatLngToXYZ = function(latLng) {
      var d2r = S2.L.LatLng.DEG_TO_RAD;

      var phi = latLng.lat*d2r;
      var theta = latLng.lng*d2r;

      var cosphi = Math.cos(phi);

      return [Math.cos(theta)*cosphi, Math.sin(theta)*cosphi, Math.sin(phi)];
    };

    S2.XYZToLatLng = function(xyz) {
      var r2d = S2.L.LatLng.RAD_TO_DEG;

      var lat = Math.atan2(xyz[2], Math.sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]));
      var lng = Math.atan2(xyz[1], xyz[0]);

      return S2.L.LatLng(lat*r2d, lng*r2d);
    };

    var largestAbsComponent = function(xyz) {
      var temp = [Math.abs(xyz[0]), Math.abs(xyz[1]), Math.abs(xyz[2])];

      if (temp[0] > temp[1]) {
        if (temp[0] > temp[2]) {
          return 0;
        } else {
          return 2;
        }
      } else {
        if (temp[1] > temp[2]) {
          return 1;
        } else {
          return 2;
        }
      }

    };

    var faceXYZToUV = function(face,xyz) {
      var u,v;

      switch (face) {
        case 0: u =  xyz[1]/xyz[0]; v =  xyz[2]/xyz[0]; break;
        case 1: u = -xyz[0]/xyz[1]; v =  xyz[2]/xyz[1]; break;
        case 2: u = -xyz[0]/xyz[2]; v = -xyz[1]/xyz[2]; break;
        case 3: u =  xyz[2]/xyz[0]; v =  xyz[1]/xyz[0]; break;
        case 4: u =  xyz[2]/xyz[1]; v = -xyz[0]/xyz[1]; break;
        case 5: u = -xyz[1]/xyz[2]; v = -xyz[0]/xyz[2]; break;
        default: throw {error: 'Invalid face'};
      }

      return [u,v];
    };




    S2.XYZToFaceUV = function(xyz) {
      var face = largestAbsComponent(xyz);

      if (xyz[face] < 0) {
        face += 3;
      }

      var uv = faceXYZToUV (face,xyz);

      return [face, uv];
    };

    S2.FaceUVToXYZ = function(face,uv) {
      var u = uv[0];
      var v = uv[1];

      switch (face) {
        case 0: return [ 1, u, v];
        case 1: return [-u, 1, v];
        case 2: return [-u,-v, 1];
        case 3: return [-1,-v,-u];
        case 4: return [ v,-1,-u];
        case 5: return [ v, u,-1];
        default: throw {error: 'Invalid face'};
      }
    };

    var singleSTtoUV = function(st) {
      if (st >= 0.5) {
        return (1/3.0) * (4*st*st - 1);
      } else {
        return (1/3.0) * (1 - (4*(1-st)*(1-st)));
      }
    };

    S2.STToUV = function(st) {
      return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
    };


    var singleUVtoST = function(uv) {
      if (uv >= 0) {
        return 0.5 * Math.sqrt (1 + 3*uv);
      } else {
        return 1 - 0.5 * Math.sqrt (1 - 3*uv);
      }
    };
    S2.UVToST = function(uv) {
      return [singleUVtoST(uv[0]), singleUVtoST(uv[1])];
    };


    S2.STToIJ = function(st,order) {
      var maxSize = (1<<order);

      var singleSTtoIJ = function(st) {
        var ij = Math.floor(st * maxSize);
        return Math.max(0, Math.min(maxSize-1, ij));
      };

      return [singleSTtoIJ(st[0]), singleSTtoIJ(st[1])];
    };


    S2.IJToST = function(ij,order,offsets) {
      var maxSize = (1<<order);

      return [
        (ij[0]+offsets[0])/maxSize,
        (ij[1]+offsets[1])/maxSize
      ];
    };



    var rotateAndFlipQuadrant = function(n, point, rx, ry)
    {
        if(ry == 0)
        {
                if(rx == 1){
                        point.x = n - 1 - point.x;
                        point.y = n - 1 - point.y;

                }

        var x = point.x;
                point.x = point.y;
                point.y = x;
        }

    };





    // hilbert space-filling curve
    // based on http://blog.notdot.net/2009/11/Damn-Cool-Algorithms-Spatial-indexing-with-Quadtrees-and-Hilbert-Curves
    // note: rather then calculating the final integer hilbert position, we just return the list of quads
    // this ensures no precision issues whth large orders (S3 cell IDs use up to 30), and is more
    // convenient for pulling out the individual bits as needed later
    var pointToHilbertQuadList = function(x,y,order,face) {
      var hilbertMap = {
        'a': [ [0,'d'], [1,'a'], [3,'b'], [2,'a'] ],
        'b': [ [2,'b'], [1,'b'], [3,'a'], [0,'c'] ],
        'c': [ [2,'c'], [3,'d'], [1,'c'], [0,'b'] ],
        'd': [ [0,'a'], [3,'c'], [1,'d'], [2,'d'] ]
      };

      if ('number' !== typeof face) {
        console.warn(new Error("called pointToHilbertQuadList without face value, defaulting to '0'").stack);
      }
      var currentSquare = (face % 2) ? 'd' : 'a';
      var positions = [];

      for (var i=order-1; i>=0; i--) {

        var mask = 1<<i;

        var quad_x = x&mask ? 1 : 0;
        var quad_y = y&mask ? 1 : 0;

        var t = hilbertMap[currentSquare][quad_x*2+quad_y];

        positions.push(t[0]);

        currentSquare = t[1];
      }

      return positions;
    };

    // S2Cell class

    S2.S2Cell = function(){};

    S2.S2Cell.FromHilbertQuadKey = function(hilbertQuadkey) {
      var parts = hilbertQuadkey.split('/');
      var face = parseInt(parts[0]);
      var position = parts[1];
      var maxLevel = position.length;
      var point = {
        x : 0,
        y: 0
      };
      var i;
      var level;
      var bit;
      var rx, ry;
      var val;

        for(i = maxLevel - 1; i >= 0; i--) {

                level = maxLevel - i;
                bit = position[i];
                rx = 0;
        ry = 0;
                if (bit === '1') {
                        ry = 1;
                }
                else if (bit === '2') {
                        rx = 1;
                        ry = 1;
                }
                else if (bit === '3') {
                        rx = 1;
                }

                val = Math.pow(2, level - 1);
                rotateAndFlipQuadrant(val, point, rx, ry);

                point.x += val * rx;
                point.y += val * ry;

        }

      if (face % 2 === 1) {
        var t = point.x;
        point.x = point.y;
        point.y = t;
      }


      return S2.S2Cell.FromFaceIJ(parseInt(face), [point.x, point.y], level);
    };

    //static method to construct
    S2.S2Cell.FromLatLng = function(latLng, level) {
      if ((!latLng.lat && latLng.lat !== 0) || (!latLng.lng && latLng.lng !== 0)) {
        throw new Error("Pass { lat: lat, lng: lng } to S2.S2Cell.FromLatLng");
      }
      var xyz = S2.LatLngToXYZ(latLng);

      var faceuv = S2.XYZToFaceUV(xyz);
      var st = S2.UVToST(faceuv[1]);

      var ij = S2.STToIJ(st,level);

      return S2.S2Cell.FromFaceIJ (faceuv[0], ij, level);
    };

    /*
    S2.faceIjLevelToXyz = function (face, ij, level) {
      var st = S2.IJToST(ij, level, [0.5, 0.5]);
      var uv = S2.STToUV(st);
      var xyz = S2.FaceUVToXYZ(face, uv);

      return S2.XYZToLatLng(xyz);
      return xyz;
    };
    */

    S2.S2Cell.FromFaceIJ = function(face,ij,level) {
      var cell = new S2.S2Cell();
      cell.face = face;
      cell.ij = ij;
      cell.level = level;

      return cell;
    };


    S2.S2Cell.prototype.toString = function() {
      return 'F'+this.face+'ij['+this.ij[0]+','+this.ij[1]+']@'+this.level;
    };

    S2.S2Cell.prototype.getLatLng = function() {
      var st = S2.IJToST(this.ij,this.level, [0.5,0.5]);
      var uv = S2.STToUV(st);
      var xyz = S2.FaceUVToXYZ(this.face, uv);

      return S2.XYZToLatLng(xyz);
    };

    S2.S2Cell.prototype.getCornerLatLngs = function() {
      var result = [];
      var offsets = [
        [ 0.0, 0.0 ],
        [ 0.0, 1.0 ],
        [ 1.0, 1.0 ],
        [ 1.0, 0.0 ]
      ];

      for (var i=0; i<4; i++) {
        var st = S2.IJToST(this.ij, this.level, offsets[i]);
        var uv = S2.STToUV(st);
        var xyz = S2.FaceUVToXYZ(this.face, uv);

        result.push ( S2.XYZToLatLng(xyz) );
      }
      return result;
    };


    S2.S2Cell.prototype.getFaceAndQuads = function () {
      var quads = pointToHilbertQuadList(this.ij[0], this.ij[1], this.level, this.face);

      return [this.face,quads];
    };
    S2.S2Cell.prototype.toHilbertQuadkey = function () {
      var quads = pointToHilbertQuadList(this.ij[0], this.ij[1], this.level, this.face);

      return this.face.toString(10) + '/' + quads.join('');
    };

    S2.latLngToNeighborKeys = S2.S2Cell.latLngToNeighborKeys = function (lat, lng, level) {
      return S2.S2Cell.FromLatLng({ lat: lat, lng: lng }, level).getNeighbors().map(function (cell) {
        return cell.toHilbertQuadkey();
      });
    };
    S2.S2Cell.prototype.getNeighbors = function() {

      var fromFaceIJWrap = function(face,ij,level) {
        var maxSize = (1<<level);
        if (ij[0]>=0 && ij[1]>=0 && ij[0]<maxSize && ij[1]<maxSize) {
          // no wrapping out of bounds
          return S2.S2Cell.FromFaceIJ(face,ij,level);
        } else {
          // the new i,j are out of range.
          // with the assumption that they're only a little past the borders we can just take the points as
          // just beyond the cube face, project to XYZ, then re-create FaceUV from the XYZ vector

          var st = S2.IJToST(ij,level,[0.5,0.5]);
          var uv = S2.STToUV(st);
          var xyz = S2.FaceUVToXYZ(face,uv);
          var faceuv = S2.XYZToFaceUV(xyz);
          face = faceuv[0];
          uv = faceuv[1];
          st = S2.UVToST(uv);
          ij = S2.STToIJ(st,level);
          return S2.S2Cell.FromFaceIJ (face, ij, level);
        }
      };

      var face = this.face;
      var i = this.ij[0];
      var j = this.ij[1];
      var level = this.level;


      return [
        fromFaceIJWrap(face, [i-1,j], level),
        fromFaceIJWrap(face, [i,j-1], level),
        fromFaceIJWrap(face, [i+1,j], level),
        fromFaceIJWrap(face, [i,j+1], level)
      ];

    };

    //
    // Functional Style
    //
    S2.FACE_BITS = 3;
    S2.MAX_LEVEL = 30;
    S2.POS_BITS = (2 * S2.MAX_LEVEL) + 1; // 61 (60 bits of data, 1 bit lsb marker)

    S2.facePosLevelToId = S2.S2Cell.facePosLevelToId = S2.fromFacePosLevel = function (faceN, posS, levelN) {
      var Long = exports.dcodeIO && exports.dcodeIO.Long || long;
      var faceB;
      var posB;
      var bin;

      if (!levelN) {
        levelN = posS.length;
      }
      if (posS.length > levelN) {
        posS = posS.substr(0, levelN);
      }

      // 3-bit face value
      faceB = Long.fromString(faceN.toString(10), true, 10).toString(2);
      while (faceB.length < S2.FACE_BITS) {
        faceB = '0' + faceB;
      }

      // 60-bit position value
      posB = Long.fromString(posS, true, 4).toString(2);
      while (posB.length < (2 * levelN)) {
        posB = '0' + posB;
      }

      bin = faceB + posB;
      // 1-bit lsb marker
      bin += '1';
      // n-bit padding to 64-bits
      while (bin.length < (S2.FACE_BITS + S2.POS_BITS)) {
        bin += '0';
      }

      return Long.fromString(bin, true, 2).toString(10);
    };

    S2.keyToId = S2.S2Cell.keyToId
    = S2.toId = S2.toCellId = S2.fromKey
    = function (key) {
      var parts = key.split('/');

      return S2.fromFacePosLevel(parts[0], parts[1], parts[1].length);
    };

    S2.idToKey = S2.S2Cell.idToKey
    = S2.S2Cell.toKey = S2.toKey
    = S2.fromId = S2.fromCellId
    = S2.S2Cell.toHilbertQuadkey  = S2.toHilbertQuadkey
    = function (idS) {
      var Long = exports.dcodeIO && exports.dcodeIO.Long || long;
      var bin = Long.fromString(idS, true, 10).toString(2);

      while (bin.length < (S2.FACE_BITS + S2.POS_BITS)) {
        bin = '0' + bin;
      }

      // MUST come AFTER binstr has been left-padded with '0's
      var lsbIndex = bin.lastIndexOf('1');
      // substr(start, len)
      // substring(start, end) // includes start, does not include end
      var faceB = bin.substring(0, 3);
      // posB will always be a multiple of 2 (or it's invalid)
      var posB = bin.substring(3, lsbIndex);
      var levelN = posB.length / 2;

      var faceS = Long.fromString(faceB, true, 2).toString(10);
      var posS = Long.fromString(posB, true, 2).toString(4);

      while (posS.length < levelN) {
        posS = '0' + posS;
      }

      return faceS + '/' + posS;
    };

    S2.keyToLatLng = S2.S2Cell.keyToLatLng = function (key) {
      var cell2 = S2.S2Cell.FromHilbertQuadKey(key);
      return cell2.getLatLng();
    };

    S2.idToLatLng = S2.S2Cell.idToLatLng = function (id) {
      var key = S2.idToKey(id);
      return S2.keyToLatLng(key);
    };

    S2.S2Cell.latLngToKey = S2.latLngToKey
    = S2.latLngToQuadkey = function (lat, lng, level) {
      if (isNaN(level) || level < 1 || level > 30) {
        throw new Error("'level' is not a number between 1 and 30 (but it should be)");
      }
      // TODO
      //
      // S2.idToLatLng(id)
      // S2.keyToLatLng(key)
      // S2.nextFace(key)     // prevent wrapping on nextKey
      // S2.prevFace(key)     // prevent wrapping on prevKey
      //
      // .toKeyArray(id)  // face,quadtree
      // .toKey(id)       // hilbert
      // .toPoint(id)     // ij
      // .toId(key)       // uint64 (as string)
      // .toLong(key)     // long.js
      // .toLatLng(id)    // object? or array?, or string (with comma)?
      //
      // maybe S2.HQ.x, S2.GPS.x, S2.CI.x?
      return S2.S2Cell.FromLatLng({ lat: lat, lng: lng }, level).toHilbertQuadkey();
    };

    S2.stepKey = function (key, num) {
      var Long = exports.dcodeIO && exports.dcodeIO.Long || long;
      var parts = key.split('/');

      var faceS = parts[0];
      var posS = parts[1];
      var level = parts[1].length;

      var posL = Long.fromString(posS, true, 4);
      // TODO handle wrapping (0 === pos + 1)
      // (only on the 12 edges of the globe)
      var otherL;
      if (num > 0) {
        otherL = posL.add(Math.abs(num));
      }
      else if (num < 0) {
        otherL = posL.subtract(Math.abs(num));
      }
      var otherS = otherL.toString(4);

      if ('0' === otherS) {
        console.warning(new Error("face/position wrapping is not yet supported"));
      }

      while (otherS.length < level) {
        otherS = '0' + otherS;
      }

      return faceS + '/' + otherS;
    };

    S2.S2Cell.prevKey = S2.prevKey = function (key) {
      return S2.stepKey(key, -1);
    };

    S2.S2Cell.nextKey = S2.nextKey = function (key) {
      return S2.stepKey(key, 1);
    };

    })(module.exports );
    });

    /**
     * @class S2GeometryProvider
     *
     * @classdesc Geometry provider based on S2 cells.
     *
     * @example
     * ```js
     * class MyDataProvider extends DataProviderBase {
     *      ...
     * }
     *
     * const geometryProvider = new S2GeometryProvider();
     * const dataProvider = new MyDataProvider(geometryProvider);
     * ```
     */
    class S2GeometryProvider extends GeometryProviderBase {
        /**
         * Create a new S2 geometry provider instance.
         */
        constructor(_level = 17) {
            super();
            this._level = _level;
        }
        /** @inheritdoc */
        bboxToCellIds(sw, ne) {
            return this._approxBboxToCellIds(sw, ne);
        }
        /** @inheritdoc */
        getAdjacent(cellId) {
            const k = s2geometry.S2.idToKey(cellId);
            const position = k.split('/')[1];
            const level = position.length;
            const [a0, a1, a2, a3] = this._getNeighbors(k, level);
            const existing = [k, a0, a1, a2, a3];
            const others = Array
                .from(new Set([
                ...this._getNeighbors(a0, level),
                ...this._getNeighbors(a1, level),
                ...this._getNeighbors(a2, level),
                ...this._getNeighbors(a3, level),
            ].filter((o) => {
                return !existing.includes(o);
            })));
            const adjacent = [a0, a1, a2, a3];
            for (const other of others) {
                let count = 0;
                for (const n of this._getNeighbors(other, level)) {
                    if (existing.includes(n)) {
                        count++;
                    }
                }
                if (count === 2) {
                    adjacent.push(other);
                }
            }
            return adjacent.map((a) => s2geometry.S2.keyToId(a));
        }
        /** @inheritdoc */
        getVertices(cellId) {
            const key = s2geometry.S2.idToKey(cellId);
            const cell = s2geometry.S2.S2Cell.FromHilbertQuadKey(key);
            return cell
                .getCornerLatLngs()
                .map((c) => {
                return { lat: c.lat, lng: c.lng };
            });
        }
        /** @inheritdoc */
        lngLatToCellId(lngLat) {
            return this._lngLatToId(lngLat, this._level);
        }
        _getNeighbors(s2key, level) {
            const latlng = s2geometry.S2.keyToLatLng(s2key);
            const neighbors = s2geometry.S2.latLngToNeighborKeys(latlng.lat, latlng.lng, level);
            return neighbors;
        }
        _lngLatToId(lngLat, level) {
            const s2key = s2geometry.S2.latLngToKey(lngLat.lat, lngLat.lng, level);
            return s2geometry.S2.keyToId(s2key);
        }
    }

    function convertCameraType(graphCameraType) {
        switch (graphCameraType) {
            case "equirectangular":
            case "spherical":
                return "spherical";
            case "fisheye":
                return "fisheye";
            default:
                return "perspective";
        }
    }
    class GraphConverter {
        clusterReconstruction(source) {
            const id = null;
            const points = source.points;
            const normalize = 1 / 255;
            for (const pointId in points) {
                if (!points.hasOwnProperty(pointId)) {
                    continue;
                }
                const color = points[pointId].color;
                color[0] *= normalize;
                color[1] *= normalize;
                color[2] *= normalize;
            }
            const lla = source.reference_lla;
            const reference = {
                alt: lla.altitude,
                lat: lla.latitude,
                lng: lla.longitude,
            };
            return {
                id,
                points,
                reference,
            };
        }
        coreImage(source) {
            const geometry = this._geometry(source.geometry);
            const computedGeometry = this._geometry(source.computed_geometry);
            const sequence = { id: source.sequence };
            const id = source.id;
            return {
                computed_geometry: computedGeometry,
                geometry,
                id,
                sequence,
            };
        }
        spatialImage(source) {
            var _a, _b, _c, _d;
            source.camera_type = convertCameraType(source.camera_type);
            source.merge_id = source.merge_cc ? source.merge_cc.toString() : null;
            source.private = null;
            const thumbUrl = source.camera_type === 'spherical' ?
                source.thumb_2048_url : source.thumb_1024_url;
            source.thumb = (_a = source.thumb) !== null && _a !== void 0 ? _a : { id: null, url: thumbUrl };
            source.cluster = (_b = source.sfm_cluster) !== null && _b !== void 0 ? _b : { id: null, url: null };
            source.creator = { id: null, username: null };
            source.owner = (_c = source.owner) !== null && _c !== void 0 ? _c : { id: null };
            source.mesh = (_d = source.mesh) !== null && _d !== void 0 ? _d : { id: null, url: null };
            return source;
        }
        _geometry(geometry) {
            const coords = geometry === null || geometry === void 0 ? void 0 : geometry.coordinates;
            const lngLat = coords ?
                {
                    lat: coords[1],
                    lng: coords[0],
                } : null;
            return lngLat;
        }
    }

    class GraphQueryCreator {
        constructor() {
            this.imagesPath = 'images';
            this.sequencePath = 'image_ids';
            this._imageTilesPath = 'tiles';
            this.coreFields = ['computed_geometry', 'geometry', 'sequence'];
            this.idFields = ['id'];
            this.spatialFields = [
                'altitude',
                'atomic_scale',
                'camera_parameters',
                'camera_type',
                'captured_at',
                'compass_angle',
                'computed_altitude',
                'computed_compass_angle',
                'computed_rotation',
                'exif_orientation',
                'height',
                'merge_cc',
                'mesh',
                'quality_score',
                'sfm_cluster',
                'thumb_1024_url',
                'thumb_2048_url',
                'width',
            ];
            this.imageTileFields = ['url', 'z', 'x', 'y'];
        }
        images(imageIds, fields) {
            return `image_ids=${imageIds.join(',')}&fields=${fields.join(',')}`;
        }
        imagesS2(cellId, fields) {
            return `s2=${cellId}&fields=${fields.join(',')}`;
        }
        imageTiles(z, fields) {
            return `z=${z}&fields=${fields.join(',')}`;
        }
        imageTilesPath(imageId) {
            return `${imageId}/${this._imageTilesPath}`;
        }
        sequence(sequenceId) {
            return `sequence_id=${sequenceId}`;
        }
    }

    class GraphDataProvider extends DataProviderBase {
        constructor(options, geometry, converter, queryCreator) {
            var _a;
            super(geometry !== null && geometry !== void 0 ? geometry : new S2GeometryProvider());
            this._convert = converter !== null && converter !== void 0 ? converter : new GraphConverter();
            this._query = queryCreator !== null && queryCreator !== void 0 ? queryCreator : new GraphQueryCreator();
            this._method = 'GET';
            const opts = options !== null && options !== void 0 ? options : {};
            this._endpoint = (_a = opts.endpoint) !== null && _a !== void 0 ? _a : "https://graph.mapillary.com";
            this._accessToken = opts.accessToken;
        }
        getCluster(url, abort) {
            return fetchArrayBuffer(url, abort)
                .then((buffer) => {
                const reconstructions = decompress(buffer);
                if (reconstructions.length < 1) {
                    throw new Error('Cluster reconstruction empty');
                }
                return this._convert
                    .clusterReconstruction(reconstructions[0]);
            });
        }
        getCoreImages(cellId) {
            const fields = [
                ...this._query.idFields,
                ...this._query.coreFields,
            ];
            const query = this._query.imagesS2(cellId, fields);
            const url = new URL(this._query.imagesPath, this._endpoint).href;
            return this
                ._fetchGraphContract(query, url)
                .then(r => {
                const result = {
                    cell_id: cellId,
                    images: [],
                };
                const items = r.data;
                for (const item of items) {
                    const coreImage = this._convert.coreImage(item);
                    result.images.push(coreImage);
                }
                return result;
            });
        }
        getImageBuffer(url, abort) {
            return fetchArrayBuffer(url, abort);
        }
        getImages(imageIds) {
            const fields = [
                ...this._query.idFields,
                ...this._query.coreFields,
                ...this._query.spatialFields,
            ];
            const query = this._query.images(imageIds, fields);
            const url = new URL(this._query.imagesPath, this._endpoint).href;
            return this
                ._fetchGraphContract(query, url)
                .then(r => {
                const result = [];
                const items = r.data;
                for (const item of items) {
                    const coreImage = this._convert.coreImage(item);
                    const spatialImage = this._convert.spatialImage(item);
                    const image = Object.assign({}, spatialImage, coreImage);
                    const contract = {
                        node: image,
                        node_id: item.id,
                    };
                    result.push(contract);
                }
                return result;
            });
        }
        getImageTiles(request) {
            const fields = [
                ...this._query.imageTileFields,
            ];
            const query = this._query.imageTiles(request.z, fields);
            const url = new URL(this._query.imageTilesPath(request.imageId), this._endpoint).href;
            return this
                ._fetchGraphContract(query, url)
                .then(r => {
                const result = {
                    node: r.data,
                    node_id: request.imageId,
                };
                return result;
            });
        }
        getMesh(url, abort) {
            return fetchArrayBuffer(url, abort)
                .then((buffer) => {
                return readMeshPbf(buffer);
            });
        }
        getSequence(sequenceId) {
            const query = this._query.sequence(sequenceId);
            const url = new URL(this._query.sequencePath, this._endpoint).href;
            return this
                ._fetchGraphContract(query, url)
                .then(r => {
                const result = {
                    id: sequenceId,
                    image_ids: r.data.map(item => item.id),
                };
                return result;
            });
        }
        getSpatialImages(imageIds) {
            const fields = [
                ...this._query.idFields,
                ...this._query.coreFields,
                ...this._query.spatialFields,
            ];
            const query = this._query.images(imageIds, fields);
            const url = new URL(this._query.imagesPath, this._endpoint).href;
            return this
                ._fetchGraphContract(query, url)
                .then(r => {
                const result = [];
                const items = r.data;
                for (const item of items) {
                    const spatialImage = this._convert.spatialImage(item);
                    const contract = {
                        node: spatialImage,
                        node_id: item.id,
                    };
                    result.push(contract);
                }
                return result;
            });
        }
        setAccessToken(accessToken) {
            this._accessToken = accessToken;
        }
        _createHeaders() {
            const headers = [
                { name: 'Accept', value: 'application/json' },
                {
                    name: 'Content-Type',
                    value: 'application/x-www-form-urlencoded',
                },
            ];
            if (this._accessToken) {
                headers.push({
                    name: 'Authorization',
                    value: `OAuth ${this._accessToken}`,
                });
            }
            return headers;
        }
        _fetchGraphContract(body, url) {
            const method = this._method;
            const headers = this._createHeaders();
            const query = `${url}?${body}`;
            return xhrFetch(query, method, "json", headers, null, null)
                .catch((error) => {
                const message = this._makeErrorMessage(error);
                throw new MapillaryError(message);
            });
        }
        _makeErrorMessage(graphError) {
            const error = graphError.error;
            const message = error ?
                `${error.code} (${error.type}, ${error.fbtrace_id}): ${error.message}` :
                "Failed to fetch data";
            return message;
        }
    }

    /**
     * @class Marker
     *
     * @classdesc Represents an abstract marker class that should be extended
     * by marker implementations used in the marker component.
     */
    class Marker {
        constructor(id, lngLat) {
            this._id = id;
            this._lngLat = lngLat;
        }
        /**
         * Get id.
         * @returns {string} The id of the marker.
         */
        get id() {
            return this._id;
        }
        /**
         * Get geometry.
         *
         * @ignore
         */
        get geometry() {
            return this._geometry;
        }
        /**
         * Get lngLat.
         * @returns {LngLat} The geographic coordinates of the marker.
         */
        get lngLat() {
            return this._lngLat;
        }
        /** @ignore */
        createGeometry(position) {
            if (!!this._geometry) {
                return;
            }
            this._createGeometry(position);
            // update matrix world if raycasting occurs before first render
            this._geometry.updateMatrixWorld(true);
        }
        /** @ignore */
        disposeGeometry() {
            if (!this._geometry) {
                return;
            }
            this._disposeGeometry();
            this._geometry = undefined;
        }
        /** @ignore */
        getInteractiveObjects() {
            if (!this._geometry) {
                return [];
            }
            return this._getInteractiveObjects();
        }
        /** @ignore */
        lerpAltitude(alt, alpha) {
            if (!this._geometry) {
                return;
            }
            this._geometry.position.z =
                (1 - alpha) * this._geometry.position.z + alpha * alt;
        }
        /** @ignore */
        updatePosition(position, lngLat) {
            if (!!lngLat) {
                this._lngLat.lat = lngLat.lat;
                this._lngLat.lng = lngLat.lng;
            }
            if (!this._geometry) {
                return;
            }
            this._geometry.position.fromArray(position);
            this._geometry.updateMatrixWorld(true);
        }
    }

    /**
     * @class CircleMarker
     *
     * @classdesc Non-interactive marker with a flat circle shape. The circle
     * marker can not be configured to be interactive.
     *
     * Circle marker properties can not be updated after creation.
     *
     * To create and add one `CircleMarker` with default configuration
     * and one with configuration use
     *
     * @example
     * ```js
     * var defaultMarker = new CircleMarker(
     *     "id-1",
     *     { lat: 0, lng: 0, });
     *
     * var configuredMarker = new CircleMarker(
     *     "id-2",
     *     { lat: 0, lng: 0, },
     *     {
     *         color: "#0ff",
     *         opacity: 0.3,
     *         radius: 0.7,
     *     });
     *
     * markerComponent.add([defaultMarker, configuredMarker]);
     * ```
     */
    class CircleMarker extends Marker {
        constructor(id, lngLat, options) {
            super(id, lngLat);
            options = !!options ? options : {};
            this._color = options.color != null ? options.color : 0xffffff;
            this._opacity = options.opacity != null ? options.opacity : 0.4;
            this._radius = options.radius != null ? options.radius : 1;
        }
        _createGeometry(position) {
            const circle = new Mesh(new CircleGeometry(this._radius, 16), new MeshBasicMaterial({
                color: this._color,
                opacity: this._opacity,
                transparent: true,
            }));
            circle.up.fromArray([0, 0, 1]);
            circle.renderOrder = -1;
            const group = new Object3D();
            group.add(circle);
            group.position.fromArray(position);
            this._geometry = group;
        }
        _disposeGeometry() {
            for (let mesh of this._geometry.children) {
                mesh.geometry.dispose();
                mesh.material.dispose();
            }
        }
        _getInteractiveObjects() {
            return [];
        }
    }

    /**
     * @class SimpleMarker
     *
     * @classdesc Interactive marker with ice cream shape. The sphere
     * inside the ice cream can be configured to be interactive.
     *
     * Simple marker properties can not be updated after creation.
     *
     * To create and add one `SimpleMarker` with default configuration
     * (non-interactive) and one interactive with configuration use
     *
     * @example
     * ```js
     * var defaultMarker = new SimpleMarker(
     *     "id-1",
     *     { lat: 0, lng: 0, });
     *
     * var interactiveMarker = new SimpleMarker(
     *     "id-2",
     *     { lat: 0, lng: 0, },
     *     {
     *         ballColor: "#00f",
     *         ballOpacity: 0.5,
     *         color: "#00f",
     *         interactive: true,
     *         opacity: 0.3,
     *         radius: 0.7,
     *     });
     *
     * markerComponent.add([defaultMarker, interactiveMarker]);
     * ```
     */
    class SimpleMarker extends Marker {
        constructor(id, lngLat, options) {
            super(id, lngLat);
            options = !!options ? options : {};
            this._ballColor = options.ballColor != null ? options.ballColor : 0xff0000;
            this._ballOpacity = options.ballOpacity != null ? options.ballOpacity : 0.8;
            this._circleToRayAngle = 2;
            this._color = options.color != null ? options.color : 0xff0000;
            this._interactive = !!options.interactive;
            this._opacity = options.opacity != null ? options.opacity : 0.4;
            this._radius = options.radius != null ? options.radius : 1;
        }
        _createGeometry(position) {
            const radius = this._radius;
            const height = this._markerHeight(radius);
            const markerMaterial = new MeshBasicMaterial({
                color: this._color,
                opacity: this._opacity,
                transparent: true,
                depthWrite: false,
            });
            const marker = new Mesh(this._createMarkerGeometry(radius, 8, 8), markerMaterial);
            const interactive = new Mesh(new SphereGeometry(radius / 2, 8, 8), new MeshBasicMaterial({
                color: this._ballColor,
                opacity: this._ballOpacity,
                transparent: true,
            }));
            interactive.position.z = height;
            interactive.renderOrder = 1;
            const group = new Object3D();
            group.add(interactive);
            group.add(marker);
            group.position.fromArray(position);
            this._geometry = group;
        }
        _disposeGeometry() {
            for (const mesh of this._geometry.children) {
                mesh.geometry.dispose();
                mesh.material.dispose();
            }
        }
        _getInteractiveObjects() {
            return this._interactive ? [this._geometry.children[0]] : [];
        }
        _markerHeight(radius) {
            const t = Math.tan(Math.PI - this._circleToRayAngle);
            return radius * Math.sqrt(1 + t * t);
        }
        _createMarkerGeometry(radius, widthSegments, heightSegments) {
            const height = this._markerHeight(radius);
            const circleToRayAngle = this._circleToRayAngle;
            const indexRows = [];
            const positions = new Float32Array(3 * (widthSegments + 1) * (heightSegments + 1));
            let positionIndex = 0;
            for (let y = 0; y <= heightSegments; ++y) {
                const indexRow = [];
                for (let x = 0; x <= widthSegments; ++x) {
                    const u = x / widthSegments * Math.PI * 2;
                    const v = y / heightSegments * Math.PI;
                    let r = radius;
                    if (v > circleToRayAngle) {
                        const t = Math.tan(v - circleToRayAngle);
                        r = radius * Math.sqrt(1 + t * t);
                    }
                    const arrayIndex = 3 * positionIndex;
                    const sinv = Math.sin(v);
                    positions[arrayIndex + 0] = r * Math.cos(u) * sinv;
                    positions[arrayIndex + 1] = r * Math.sin(u) * sinv;
                    positions[arrayIndex + 2] = r * Math.cos(v) + height;
                    indexRow.push(positionIndex++);
                }
                indexRows.push(indexRow);
            }
            const indices = new Uint16Array(6 * widthSegments * heightSegments);
            let index = 0;
            for (let y = 0; y < heightSegments; ++y) {
                for (let x = 0; x < widthSegments; ++x) {
                    const pi1 = indexRows[y][x + 1];
                    const pi2 = indexRows[y][x];
                    const pi3 = indexRows[y + 1][x];
                    const pi4 = indexRows[y + 1][x + 1];
                    indices[index++] = pi1;
                    indices[index++] = pi2;
                    indices[index++] = pi4;
                    indices[index++] = pi2;
                    indices[index++] = pi3;
                    indices[index++] = pi4;
                }
            }
            const geometry = new BufferGeometry();
            const positionAttribute = new BufferAttribute(positions, 3);
            geometry.setAttribute("position", positionAttribute);
            geometry.setIndex(new BufferAttribute(indices, 1));
            return geometry;
        }
    }

    /**
     * @class Popup
     *
     * @classdesc Popup instance for rendering custom HTML content
     * on top of images. Popups are based on 2D basic image coordinates
     * (see the {@link Viewer} class documentation for more information about coordinate
     * systems) and a certain popup is therefore only relevant to a single image.
     * Popups related to a certain image should be removed when moving
     * to another image.
     *
     * A popup must have both its content and its point or rect set to be
     * rendered. Popup options can not be updated after creation but the
     * basic point or rect as well as its content can be changed by calling
     * the appropriate methods.
     *
     * To create and add one `Popup` with default configuration
     * (tooltip visuals and automatic float) and one with specific options
     * use
     *
     * @example
     * ```js
     * var defaultSpan = document.createElement('span');
     * defaultSpan.innerHTML = 'hello default';
     *
     * var defaultPopup = new Popup();
     * defaultPopup.setDOMContent(defaultSpan);
     * defaultPopup.setBasicPoint([0.3, 0.3]);
     *
     * var cleanSpan = document.createElement('span');
     * cleanSpan.innerHTML = 'hello clean';
     *
     * var cleanPopup = new Popup({
     *     clean: true,
     *     float: Alignment.Top,
     *     offset: 10,
     *     opacity: 0.7,
     * });
     *
     * cleanPopup.setDOMContent(cleanSpan);
     * cleanPopup.setBasicPoint([0.6, 0.6]);
     *
     * popupComponent.add([defaultPopup, cleanPopup]);
     * ```
     *
     * @description Implementation of API methods and API documentation inspired
     * by/used from https://github.com/mapbox/mapbox-gl-js/blob/v0.38.0/src/ui/popup.js
     */
    class Popup {
        constructor(options, viewportCoords, dom) {
            this._options = {};
            options = !!options ? options : {};
            this._options.capturePointer = options.capturePointer === false ?
                options.capturePointer : true;
            this._options.clean = options.clean;
            this._options.float = options.float;
            this._options.offset = options.offset;
            this._options.opacity = options.opacity;
            this._options.position = options.position;
            this._dom = !!dom ? dom : new DOM();
            this._viewportCoords = !!viewportCoords ? viewportCoords : new ViewportCoords();
            this._notifyChanged$ = new Subject();
        }
        /**
         * @description Internal observable used by the component to
         * render the popup when its position or content has changed.
         * @ignore
         */
        get changed$() {
            return this._notifyChanged$;
        }
        /**
         * @description Internal method used by the component to
         * remove all references to the popup.
         * @ignore
         */
        remove() {
            if (this._content && this._content.parentNode) {
                this._content.parentNode.removeChild(this._content);
            }
            if (this._container) {
                this._container.parentNode.removeChild(this._container);
                delete this._container;
            }
            if (this._parentContainer) {
                delete this._parentContainer;
            }
        }
        /**
         * Sets a 2D basic image coordinates point to the popup's anchor, and
         * moves the popup to it.
         *
         * @description Overwrites any previously set point or rect.
         *
         * @param {Array<number>} basicPoint - Point in 2D basic image coordinates.
         *
         * @example
         * ```js
         * var popup = new Popup();
         * popup.setText('hello image');
         * popup.setBasicPoint([0.3, 0.3]);
         *
         * popupComponent.add([popup]);
         * ```
         */
        setBasicPoint(basicPoint) {
            this._point = basicPoint.slice();
            this._rect = null;
            this._notifyChanged$.next(this);
        }
        /**
         * Sets a 2D basic image coordinates rect to the popup's anchor, and
         * moves the popup to it.
         *
         * @description Overwrites any previously set point or rect.
         *
         * @param {Array<number>} basicRect - Rect in 2D basic image
         * coordinates ([topLeftX, topLeftY, bottomRightX, bottomRightY]) .
         *
         * @example
         * ```js
         * var popup = new Popup();
         * popup.setText('hello image');
         * popup.setBasicRect([0.3, 0.3, 0.5, 0.6]);
         *
         * popupComponent.add([popup]);
         * ```
         */
        setBasicRect(basicRect) {
            this._rect = basicRect.slice();
            this._point = null;
            this._notifyChanged$.next(this);
        }
        /**
         * Sets the popup's content to the element provided as a DOM node.
         *
         * @param {Node} htmlNode - A DOM node to be used as content for the popup.
         *
         * @example
         * ```js
         * var div = document.createElement('div');
         * div.innerHTML = 'hello image';
         *
         * var popup = new Popup();
         * popup.setDOMContent(div);
         * popup.setBasicPoint([0.3, 0.3]);
         *
         * popupComponent.add([popup]);
         * ```
         */
        setDOMContent(htmlNode) {
            if (this._content && this._content.parentNode) {
                this._content.parentNode.removeChild(this._content);
            }
            const className = "mapillary-popup-content" +
                (this._options.clean === true ? "-clean" : "") +
                (this._options.capturePointer === true ? " mapillary-popup-capture-pointer" : "");
            this._content = this._dom.createElement("div", className, this._container);
            this._content.appendChild(htmlNode);
            this._notifyChanged$.next(this);
        }
        /**
         * Sets the popup's content to the HTML provided as a string.
         *
         * @description This method does not perform HTML filtering or sanitization,
         * and must be used only with trusted content. Consider
         * {@link Popup.setText} if the
         * content is an untrusted text string.
         *
         * @param {string} html - A string representing HTML content for the popup.
         *
         * @example
         * ```js
         * var popup = new Popup();
         * popup.setHTML('<div>hello image</div>');
         * popup.setBasicPoint([0.3, 0.3]);
         *
         * popupComponent.add([popup]);
         * ```
         */
        setHTML(html) {
            const frag = this._dom.document.createDocumentFragment();
            const temp = this._dom.createElement("body");
            let child;
            temp.innerHTML = html;
            while (true) {
                child = temp.firstChild;
                if (!child) {
                    break;
                }
                frag.appendChild(child);
            }
            this.setDOMContent(frag);
        }
        /**
         * Sets the popup's content to a string of text.
         *
         * @description This function creates a Text node in the DOM, so it cannot insert raw HTML.
         * Use this method for security against XSS if the popup content is user-provided.
         *
         * @param {string} text - Textual content for the popup.
         *
         * @example
         * ```js
         * var popup = new Popup();
         * popup.setText('hello image');
         * popup.setBasicPoint([0.3, 0.3]);
         *
         * popupComponent.add([popup]);
         * ```
         */
        setText(text) {
            this.setDOMContent(this._dom.document.createTextNode(text));
        }
        /**
         * @description Internal method for attaching the popup to
         * its parent container so that it is rendered in the DOM tree.
         * @ignore
         */
        setParentContainer(parentContainer) {
            this._parentContainer = parentContainer;
        }
        /**
         * @description Internal method for updating the rendered
         * position of the popup called by the popup component.
         * @ignore
         */
        update(renderCamera, size, transform) {
            if (!this._parentContainer || !this._content) {
                return;
            }
            if (!this._point && !this._rect) {
                return;
            }
            if (!this._container) {
                this._container = this._dom.createElement("div", "mapillary-popup", this._parentContainer);
                const showTip = this._options.clean !== true &&
                    this._options.float !== exports.Alignment.Center;
                if (showTip) {
                    const tipClassName = "mapillary-popup-tip" +
                        (this._options.capturePointer === true ? " mapillary-popup-capture-pointer" : "");
                    this._tip = this._dom.createElement("div", tipClassName, this._container);
                    this._dom.createElement("div", "mapillary-popup-tip-inner", this._tip);
                }
                this._container.appendChild(this._content);
                this._parentContainer.appendChild(this._container);
                if (this._options.opacity != null) {
                    this._container.style.opacity = this._options.opacity.toString();
                }
            }
            let pointPixel = null;
            let position = this._alignmentToPopupAligment(this._options.position);
            let float = this._alignmentToPopupAligment(this._options.float);
            const classList = this._container.classList;
            if (this._point != null) {
                pointPixel =
                    this._viewportCoords.basicToCanvasSafe(this._point[0], this._point[1], { offsetHeight: size.height, offsetWidth: size.width }, transform, renderCamera.perspective);
            }
            else {
                const alignments = ["center", "top", "bottom", "left", "right", "top-left", "top-right", "bottom-left", "bottom-right"];
                let appliedPosition = null;
                for (const alignment of alignments) {
                    if (classList.contains(`mapillary-popup-float-${alignment}`)) {
                        appliedPosition = alignment;
                        break;
                    }
                }
                [pointPixel, position] = this._rectToPixel(this._rect, position, appliedPosition, renderCamera, size, transform);
                if (!float) {
                    float = position;
                }
            }
            if (pointPixel == null) {
                this._container.style.display = "none";
                return;
            }
            this._container.style.display = "";
            if (!float) {
                const width = this._container.offsetWidth;
                const height = this._container.offsetHeight;
                const floats = this._pixelToFloats(pointPixel, size, width, height);
                float = floats.length === 0 ? "top" : floats.join("-");
            }
            const offset = this._normalizeOffset(this._options.offset);
            pointPixel = [pointPixel[0] + offset[float][0], pointPixel[1] + offset[float][1]];
            pointPixel = [Math.round(pointPixel[0]), Math.round(pointPixel[1])];
            const floatTranslate = {
                "bottom": "translate(-50%,0)",
                "bottom-left": "translate(-100%,0)",
                "bottom-right": "translate(0,0)",
                "center": "translate(-50%,-50%)",
                "left": "translate(-100%,-50%)",
                "right": "translate(0,-50%)",
                "top": "translate(-50%,-100%)",
                "top-left": "translate(-100%,-100%)",
                "top-right": "translate(0,-100%)",
            };
            for (const key in floatTranslate) {
                if (!floatTranslate.hasOwnProperty(key)) {
                    continue;
                }
                classList.remove(`mapillary-popup-float-${key}`);
            }
            classList.add(`mapillary-popup-float-${float}`);
            this._container.style.transform = `${floatTranslate[float]} translate(${pointPixel[0]}px,${pointPixel[1]}px)`;
        }
        _rectToPixel(rect, position, appliedPosition, renderCamera, size, transform) {
            if (!position) {
                const width = this._container.offsetWidth;
                const height = this._container.offsetHeight;
                const floatOffsets = {
                    "bottom": [0, height / 2],
                    "bottom-left": [-width / 2, height / 2],
                    "bottom-right": [width / 2, height / 2],
                    "left": [-width / 2, 0],
                    "right": [width / 2, 0],
                    "top": [0, -height / 2],
                    "top-left": [-width / 2, -height / 2],
                    "top-right": [width / 2, -height / 2],
                };
                const automaticPositions = ["top", "bottom", "left", "right"];
                let largestVisibleArea = [0, null, null];
                for (const automaticPosition of automaticPositions) {
                    const autoPointBasic = this._pointFromRectPosition(rect, automaticPosition);
                    const autoPointPixel = this._viewportCoords.basicToCanvasSafe(autoPointBasic[0], autoPointBasic[1], { offsetHeight: size.height, offsetWidth: size.width }, transform, renderCamera.perspective);
                    if (autoPointPixel == null) {
                        continue;
                    }
                    const floatOffset = floatOffsets[automaticPosition];
                    const offsetedPosition = [autoPointPixel[0] + floatOffset[0], autoPointPixel[1] + floatOffset[1]];
                    const staticCoeff = appliedPosition != null && appliedPosition === automaticPosition ? 1 : 0.7;
                    const floats = this._pixelToFloats(offsetedPosition, size, width / staticCoeff, height / (2 * staticCoeff));
                    if (floats.length === 0 &&
                        autoPointPixel[0] > 0 &&
                        autoPointPixel[0] < size.width &&
                        autoPointPixel[1] > 0 &&
                        autoPointPixel[1] < size.height) {
                        return [autoPointPixel, automaticPosition];
                    }
                    const minX = Math.max(offsetedPosition[0] - width / 2, 0);
                    const maxX = Math.min(offsetedPosition[0] + width / 2, size.width);
                    const minY = Math.max(offsetedPosition[1] - height / 2, 0);
                    const maxY = Math.min(offsetedPosition[1] + height / 2, size.height);
                    const visibleX = Math.max(0, maxX - minX);
                    const visibleY = Math.max(0, maxY - minY);
                    const visibleArea = staticCoeff * visibleX * visibleY;
                    if (visibleArea > largestVisibleArea[0]) {
                        largestVisibleArea[0] = visibleArea;
                        largestVisibleArea[1] = autoPointPixel;
                        largestVisibleArea[2] = automaticPosition;
                    }
                }
                if (largestVisibleArea[0] > 0) {
                    return [largestVisibleArea[1], largestVisibleArea[2]];
                }
            }
            const pointBasic = this._pointFromRectPosition(rect, position);
            const pointPixel = this._viewportCoords.basicToCanvasSafe(pointBasic[0], pointBasic[1], { offsetHeight: size.height, offsetWidth: size.width }, transform, renderCamera.perspective);
            return [pointPixel, position != null ? position : "top"];
        }
        _alignmentToPopupAligment(float) {
            switch (float) {
                case exports.Alignment.Bottom:
                    return "bottom";
                case exports.Alignment.BottomLeft:
                    return "bottom-left";
                case exports.Alignment.BottomRight:
                    return "bottom-right";
                case exports.Alignment.Center:
                    return "center";
                case exports.Alignment.Left:
                    return "left";
                case exports.Alignment.Right:
                    return "right";
                case exports.Alignment.Top:
                    return "top";
                case exports.Alignment.TopLeft:
                    return "top-left";
                case exports.Alignment.TopRight:
                    return "top-right";
                default:
                    return null;
            }
        }
        _normalizeOffset(offset) {
            if (offset == null) {
                return this._normalizeOffset(0);
            }
            if (typeof offset === "number") {
                // input specifies a radius
                const sideOffset = offset;
                const sign = sideOffset >= 0 ? 1 : -1;
                const cornerOffset = sign * Math.round(Math.sqrt(0.5 * Math.pow(sideOffset, 2)));
                return {
                    "bottom": [0, sideOffset],
                    "bottom-left": [-cornerOffset, cornerOffset],
                    "bottom-right": [cornerOffset, cornerOffset],
                    "center": [0, 0],
                    "left": [-sideOffset, 0],
                    "right": [sideOffset, 0],
                    "top": [0, -sideOffset],
                    "top-left": [-cornerOffset, -cornerOffset],
                    "top-right": [cornerOffset, -cornerOffset],
                };
            }
            else {
                // input specifes a value for each position
                return {
                    "bottom": offset.bottom || [0, 0],
                    "bottom-left": offset.bottomLeft || [0, 0],
                    "bottom-right": offset.bottomRight || [0, 0],
                    "center": offset.center || [0, 0],
                    "left": offset.left || [0, 0],
                    "right": offset.right || [0, 0],
                    "top": offset.top || [0, 0],
                    "top-left": offset.topLeft || [0, 0],
                    "top-right": offset.topRight || [0, 0],
                };
            }
        }
        _pixelToFloats(pointPixel, size, width, height) {
            const floats = [];
            if (pointPixel[1] < height) {
                floats.push("bottom");
            }
            else if (pointPixel[1] > size.height - height) {
                floats.push("top");
            }
            if (pointPixel[0] < width / 2) {
                floats.push("right");
            }
            else if (pointPixel[0] > size.width - width / 2) {
                floats.push("left");
            }
            return floats;
        }
        _pointFromRectPosition(rect, position) {
            const x0 = rect[0];
            const x1 = rect[0] < rect[2] ? rect[2] : rect[2] + 1;
            const y0 = rect[1];
            const y1 = rect[3];
            switch (position) {
                case "bottom":
                    return [(x0 + x1) / 2, y1];
                case "bottom-left":
                    return [x0, y1];
                case "bottom-right":
                    return [x1, y1];
                case "center":
                    return [(x0 + x1) / 2, (y0 + y1) / 2];
                case "left":
                    return [x0, (y0 + y1) / 2];
                case "right":
                    return [x1, (y0 + y1) / 2];
                case "top":
                    return [(x0 + x1) / 2, y0];
                case "top-left":
                    return [x0, y0];
                case "top-right":
                    return [x1, y0];
                default:
                    return [(x0 + x1) / 2, y1];
            }
        }
    }

    function isBrowser() {
        return (typeof window !== "undefined" &&
            typeof document !== "undefined");
    }
    function isArraySupported() {
        return !!(Array.prototype &&
            Array.prototype.concat &&
            Array.prototype.filter &&
            Array.prototype.includes &&
            Array.prototype.indexOf &&
            Array.prototype.join &&
            Array.prototype.map &&
            Array.prototype.push &&
            Array.prototype.pop &&
            Array.prototype.reverse &&
            Array.prototype.shift &&
            Array.prototype.slice &&
            Array.prototype.splice &&
            Array.prototype.sort &&
            Array.prototype.unshift);
    }
    function isBlobSupported() {
        return ("Blob" in window &&
            "URL" in window);
    }
    function isFunctionSupported() {
        return !!(Function.prototype &&
            Function.prototype.apply &&
            Function.prototype.bind);
    }
    function isJSONSupported() {
        return ("JSON" in window &&
            "parse" in JSON &&
            "stringify" in JSON);
    }
    function isMapSupported() {
        return "Map" in window;
    }
    function isObjectSupported() {
        return !!(Object.assign &&
            Object.keys &&
            Object.values);
    }
    function isPromiseSupported() {
        return !!("Promise" in window &&
            Promise.resolve &&
            Promise.reject &&
            Promise.prototype &&
            Promise.prototype.catch &&
            Promise.prototype.then);
    }
    function isSetSupported() {
        return "Set" in window;
    }
    let isWebGLSupportedCache = undefined;
    function isWebGLSupportedCached() {
        if (isWebGLSupportedCache === undefined) {
            isWebGLSupportedCache = isWebGLSupported();
        }
        return isWebGLSupportedCache;
    }
    function isWebGLSupported() {
        const attributes = {
            alpha: false,
            antialias: false,
            depth: true,
            failIfMajorPerformanceCaveat: false,
            premultipliedAlpha: true,
            preserveDrawingBuffer: false,
            stencil: true,
        };
        const canvas = document.createElement("canvas");
        const webGL2Context = canvas.getContext("webgl2", attributes);
        if (!!webGL2Context) {
            return true;
        }
        const context = canvas.getContext("webgl", attributes) ||
            canvas
                .getContext("experimental-webgl", attributes);
        if (!context) {
            return false;
        }
        const requiredExtensions = ["OES_standard_derivatives"];
        const supportedExtensions = context.getSupportedExtensions();
        for (const requiredExtension of requiredExtensions) {
            if (supportedExtensions.indexOf(requiredExtension) === -1) {
                return false;
            }
        }
        return true;
    }
    /**
     * Test whether the current browser supports the full
     * functionality of MapillaryJS.
     *
     * @description The full functionality includes WebGL rendering.
     *
     * @return {boolean}
     *
     * @example `var supported = isSupported();`
     */
    function isSupported() {
        return isFallbackSupported() &&
            isWebGLSupportedCached();
    }
    /**
     * Test whether the current browser supports the fallback
     * functionality of MapillaryJS.
     *
     * @description The fallback functionality does not include WebGL
     * rendering, only 2D canvas rendering.
     *
     * @return {boolean}
     *
     * @example `var fallbackSupported = isFallbackSupported();`
     */
    function isFallbackSupported() {
        return isBrowser() &&
            isArraySupported() &&
            isBlobSupported() &&
            isFunctionSupported() &&
            isJSONSupported() &&
            isMapSupported() &&
            isObjectSupported() &&
            isPromiseSupported() &&
            isSetSupported();
    }

    /**
     * Enumeration for camera controls.
     *
     * @description Specifies different modes for how the
     * camera is controlled through pointer, keyboard or
     * other modes of input.
     *
     * @enum {number}
     * @readonly
     */
    exports.CameraControls = void 0;
    (function (CameraControls) {
        /**
         * Control the camera with custom logic by
         * attaching a custom camera controls
         * instance to the {@link Viewer}.
         */
        CameraControls[CameraControls["Custom"] = 0] = "Custom";
        /**
         * Control the camera from a birds perspective
         * to get an overview.
         */
        CameraControls[CameraControls["Earth"] = 1] = "Earth";
        /**
         * Control the camera in a first person view
         * from the street level perspective.
         */
        CameraControls[CameraControls["Street"] = 2] = "Street";
    })(exports.CameraControls || (exports.CameraControls = {}));

    /**
     * Enumeration for render mode
     * @enum {number}
     * @readonly
     * @description Modes for specifying how rendering is done
     * in the viewer. All modes preserves the original aspect
     * ratio of the images.
     */
    exports.RenderMode = void 0;
    (function (RenderMode) {
        /**
         * Displays all content within the viewer.
         *
         * @description Black bars shown on both
         * sides of the content. Bars are shown
         * either below and above or to the left
         * and right of the content depending on
         * the aspect ratio relation between the
         * image and the viewer.
         */
        RenderMode[RenderMode["Letterbox"] = 0] = "Letterbox";
        /**
         * Fills the viewer by cropping content.
         *
         * @description Cropping is done either
         * in horizontal or vertical direction
         * depending on the aspect ratio relation
         * between the image and the viewer.
         */
        RenderMode[RenderMode["Fill"] = 1] = "Fill";
    })(exports.RenderMode || (exports.RenderMode = {}));

    exports.RenderPass = void 0;
    (function (RenderPass) {
        /**
         * Occurs after the background render pass.
         */
        RenderPass[RenderPass["Opaque"] = 0] = "Opaque";
    })(exports.RenderPass || (exports.RenderPass = {}));

    class ComponentController {
        constructor(container, navigator, observer, key, options, componentService) {
            this._container = container;
            this._observer = observer;
            this._navigator = navigator;
            this._options = options != null ? options : {};
            this._key = key;
            this._navigable = key == null;
            this._componentService = !!componentService ?
                componentService :
                new ComponentService(this._container, this._navigator);
            this._coverComponent = this._componentService.getCover();
            this._initializeComponents();
            if (key) {
                this._initilizeCoverComponent();
                this._subscribeCoverComponent();
            }
            else {
                this._navigator.movedToId$.pipe(first((k) => {
                    return k != null;
                }))
                    .subscribe((k) => {
                    this._key = k;
                    this._componentService.deactivateCover();
                    this._coverComponent.configure({
                        id: this._key,
                        state: CoverState.Hidden,
                    });
                    this._subscribeCoverComponent();
                    this._navigator.stateService.start();
                    this._navigator.cacheService.start();
                    this._navigator.panService.start();
                    this._observer.startEmit();
                });
            }
        }
        get navigable() {
            return this._navigable;
        }
        get(name) {
            return this._componentService.get(name);
        }
        activate(name) {
            this._componentService.activate(name);
        }
        activateCover() {
            this._coverComponent.configure({ state: CoverState.Visible });
        }
        deactivate(name) {
            this._componentService.deactivate(name);
        }
        deactivateCover() {
            this._coverComponent.configure({ state: CoverState.Loading });
        }
        remove() {
            this._componentService.remove();
            if (this._configurationSubscription != null) {
                this._configurationSubscription.unsubscribe();
            }
        }
        _initializeComponents() {
            var _a, _b;
            const options = this._options;
            this._uFalse((_a = options.fallback) === null || _a === void 0 ? void 0 : _a.image, "imagefallback");
            this._uFalse((_b = options.fallback) === null || _b === void 0 ? void 0 : _b.navigation, "navigationfallback");
            this._uFalse(options.marker, "marker");
            this._uFalse(options.popup, "popup");
            this._uFalse(options.slider, "slider");
            this._uFalse(options.spatial, "spatial");
            this._uFalse(options.tag, "tag");
            this._uTrue(options.attribution, "attribution");
            this._uTrue(options.bearing, "bearing");
            this._uTrue(options.cache, "cache");
            this._uTrue(options.direction, "direction");
            this._uTrue(options.image, "image");
            this._uTrue(options.keyboard, "keyboard");
            this._uTrue(options.pointer, "pointer");
            this._uTrue(options.sequence, "sequence");
            this._uTrue(options.zoom, "zoom");
        }
        _initilizeCoverComponent() {
            let options = this._options;
            this._coverComponent.configure({ id: this._key });
            if (options.cover === undefined || options.cover) {
                this.activateCover();
            }
            else {
                this.deactivateCover();
            }
        }
        _setNavigable(navigable) {
            if (this._navigable === navigable) {
                return;
            }
            this._navigable = navigable;
            this._observer.navigable$.next(navigable);
        }
        _subscribeCoverComponent() {
            this._configurationSubscription =
                this._coverComponent.configuration$.pipe(distinctUntilChanged(undefined, (c) => {
                    return c.state;
                }))
                    .subscribe((conf) => {
                    if (conf.state === CoverState.Loading) {
                        this._navigator.stateService.currentId$.pipe(first(), switchMap((key) => {
                            const keyChanged = key == null || key !== conf.id;
                            if (keyChanged) {
                                this._setNavigable(false);
                            }
                            return keyChanged ?
                                this._navigator.moveTo$(conf.id) :
                                this._navigator.stateService.currentImage$.pipe(first());
                        }))
                            .subscribe(() => {
                            this._navigator.stateService.start();
                            this._navigator.cacheService.start();
                            this._navigator.panService.start();
                            this._observer.startEmit();
                            this._coverComponent.configure({ state: CoverState.Hidden });
                            this._componentService.deactivateCover();
                            this._setNavigable(true);
                        }, (error) => {
                            console.error("Failed to deactivate cover.", error);
                            this._coverComponent.configure({ state: CoverState.Visible });
                        });
                    }
                    else if (conf.state === CoverState.Visible) {
                        this._observer.stopEmit();
                        this._navigator.stateService.stop();
                        this._navigator.cacheService.stop();
                        this._navigator.playService.stop();
                        this._navigator.panService.stop();
                        this._componentService.activateCover();
                        this._setNavigable(conf.id == null);
                    }
                });
        }
        _uFalse(option, name) {
            if (option === undefined) {
                this._componentService.deactivate(name);
                return;
            }
            if (typeof option === "boolean") {
                if (option) {
                    this._componentService.activate(name);
                }
                else {
                    this._componentService.deactivate(name);
                }
                return;
            }
            this._componentService.configure(name, option);
            this._componentService.activate(name);
        }
        _uTrue(option, name) {
            if (option === undefined) {
                this._componentService.activate(name);
                return;
            }
            if (typeof option === "boolean") {
                if (option) {
                    this._componentService.activate(name);
                }
                else {
                    this._componentService.deactivate(name);
                }
                return;
            }
            this._componentService.configure(name, option);
            this._componentService.activate(name);
        }
    }

    class DOMRenderer {
        constructor(element, renderService, currentFrame$) {
            this._adaptiveOperation$ = new Subject();
            this._render$ = new Subject();
            this._renderAdaptive$ = new Subject();
            this._subscriptions = new SubscriptionHolder();
            this._renderService = renderService;
            this._currentFrame$ = currentFrame$;
            const subs = this._subscriptions;
            const rootNode = virtualDom.create(virtualDom.h("div.mapillary-dom-renderer", []));
            element.appendChild(rootNode);
            this._offset$ = this._adaptiveOperation$.pipe(scan((adaptive, operation) => {
                return operation(adaptive);
            }, {
                elementHeight: element.offsetHeight,
                elementWidth: element.offsetWidth,
                imageAspect: 0,
                renderMode: exports.RenderMode.Fill,
            }), filter((adaptive) => {
                return adaptive.imageAspect > 0 && adaptive.elementWidth > 0 && adaptive.elementHeight > 0;
            }), map((adaptive) => {
                const elementAspect = adaptive.elementWidth / adaptive.elementHeight;
                const ratio = adaptive.imageAspect / elementAspect;
                let verticalOffset = 0;
                let horizontalOffset = 0;
                if (adaptive.renderMode === exports.RenderMode.Letterbox) {
                    if (adaptive.imageAspect > elementAspect) {
                        verticalOffset = adaptive.elementHeight * (1 - 1 / ratio) / 2;
                    }
                    else {
                        horizontalOffset = adaptive.elementWidth * (1 - ratio) / 2;
                    }
                }
                else {
                    if (adaptive.imageAspect > elementAspect) {
                        horizontalOffset = -adaptive.elementWidth * (ratio - 1) / 2;
                    }
                    else {
                        verticalOffset = -adaptive.elementHeight * (1 / ratio - 1) / 2;
                    }
                }
                return {
                    bottom: verticalOffset,
                    left: horizontalOffset,
                    right: horizontalOffset,
                    top: verticalOffset,
                };
            }));
            const imageAspectSubscription = this._currentFrame$.pipe(filter((frame) => {
                return frame.state.currentImage != null;
            }), distinctUntilChanged((k1, k2) => {
                return k1 === k2;
            }, (frame) => {
                return frame.state.currentImage.id;
            }), map((frame) => {
                return frame.state.currentTransform.basicAspect;
            }), map((aspect) => {
                return (adaptive) => {
                    adaptive.imageAspect = aspect;
                    return adaptive;
                };
            }))
                .subscribe(this._adaptiveOperation$);
            const renderAdaptiveSubscription = combineLatest(this._renderAdaptive$.pipe(scan((vNodeHashes, vNodeHash) => {
                if (vNodeHash.vNode == null) {
                    delete vNodeHashes[vNodeHash.name];
                }
                else {
                    vNodeHashes[vNodeHash.name] = vNodeHash.vNode;
                }
                return vNodeHashes;
            }, {})), this._offset$).pipe(map((vo) => {
                const vNodes = [];
                const hashes = vo[0];
                for (const name in hashes) {
                    if (!hashes.hasOwnProperty(name)) {
                        continue;
                    }
                    vNodes.push(hashes[name]);
                }
                const offset = vo[1];
                const properties = {
                    style: {
                        bottom: offset.bottom + "px",
                        left: offset.left + "px",
                        "pointer-events": "none",
                        position: "absolute",
                        right: offset.right + "px",
                        top: offset.top + "px",
                    },
                };
                return {
                    name: "mapillary-dom-adaptive-renderer",
                    vNode: virtualDom.h("div.mapillary-dom-adaptive-renderer", properties, vNodes),
                };
            }))
                .subscribe(this._render$);
            this._vNode$ = this._render$.pipe(scan((vNodeHashes, vNodeHash) => {
                if (vNodeHash.vNode == null) {
                    delete vNodeHashes[vNodeHash.name];
                }
                else {
                    vNodeHashes[vNodeHash.name] = vNodeHash.vNode;
                }
                return vNodeHashes;
            }, {}), map((hashes) => {
                const vNodes = [];
                for (const name in hashes) {
                    if (!hashes.hasOwnProperty(name)) {
                        continue;
                    }
                    vNodes.push(hashes[name]);
                }
                return virtualDom.h("div.mapillary-dom-renderer", vNodes);
            }));
            this._vPatch$ = this._vNode$.pipe(scan((nodePatch, vNode) => {
                nodePatch.vpatch = virtualDom.diff(nodePatch.vNode, vNode);
                nodePatch.vNode = vNode;
                return nodePatch;
            }, { vNode: virtualDom.h("div.mapillary-dom-renderer", []), vpatch: null }), pluck("vpatch"));
            this._element$ = this._vPatch$.pipe(scan((oldElement, vPatch) => {
                return virtualDom.patch(oldElement, vPatch);
            }, rootNode), publishReplay(1), refCount());
            subs.push(imageAspectSubscription);
            subs.push(renderAdaptiveSubscription);
            subs.push(this._element$.subscribe(() => { }));
            subs.push(this._renderService.size$.pipe(map((size) => {
                return (adaptive) => {
                    adaptive.elementWidth = size.width;
                    adaptive.elementHeight = size.height;
                    return adaptive;
                };
            }))
                .subscribe(this._adaptiveOperation$));
            subs.push(this._renderService.renderMode$.pipe(map((renderMode) => {
                return (adaptive) => {
                    adaptive.renderMode = renderMode;
                    return adaptive;
                };
            }))
                .subscribe(this._adaptiveOperation$));
        }
        get element$() {
            return this._element$;
        }
        get render$() {
            return this._render$;
        }
        get renderAdaptive$() {
            return this._renderAdaptive$;
        }
        clear(name) {
            this._renderAdaptive$.next({ name: name, vNode: null });
            this._render$.next({ name: name, vNode: null });
        }
        remove() {
            this._subscriptions.unsubscribe();
        }
    }

    class GLRenderer {
        constructor(canvas, canvasContainer, renderService) {
            this._renderFrame$ = new Subject();
            this._renderCameraOperation$ = new Subject();
            this._render$ = new Subject();
            this._clear$ = new Subject();
            this._renderOperation$ = new Subject();
            this._rendererOperation$ = new Subject();
            this._eraserOperation$ = new Subject();
            this._triggerOperation$ = new Subject();
            this._subscriptions = new SubscriptionHolder();
            this._opaqueRender$ = new Subject();
            this._renderService = renderService;
            const subs = this._subscriptions;
            this._renderer$ = this._rendererOperation$.pipe(scan((renderer, operation) => {
                return operation(renderer);
            }, { needsRender: false, renderer: null }), filter((renderer) => {
                return !!renderer.renderer;
            }));
            this._renderCollection$ = this._renderOperation$.pipe(scan((hashes, operation) => {
                return operation(hashes);
            }, {}), share());
            this._renderCamera$ = this._renderCameraOperation$.pipe(scan((rc, operation) => {
                return operation(rc);
            }, { frameId: -1, needsRender: false, perspective: null }));
            this._eraser$ = this._eraserOperation$.pipe(startWith((eraser) => {
                return eraser;
            }), scan((eraser, operation) => {
                return operation(eraser);
            }, { needsRender: false }));
            const trigger$ = this._triggerOperation$.pipe(startWith((trigger) => {
                return trigger;
            }), scan((trigger, operation) => {
                return operation(trigger);
            }, { needsRender: false }));
            const clearColor = new Color(0x0F0F0F);
            const renderSubscription = combineLatest(this._renderer$, this._renderCollection$, this._renderCamera$, this._eraser$, trigger$).pipe(map(([renderer, hashes, rc, eraser, trigger]) => {
                const renders = Object.keys(hashes)
                    .map((key) => {
                    return hashes[key];
                });
                return { camera: rc, eraser: eraser, trigger: trigger, renderer: renderer, renders: renders };
            }), filter((co) => {
                let needsRender = co.renderer.needsRender ||
                    co.camera.needsRender ||
                    co.eraser.needsRender ||
                    co.trigger.needsRender;
                const frameId = co.camera.frameId;
                for (const render of co.renders) {
                    if (render.frameId !== frameId) {
                        return false;
                    }
                    needsRender = needsRender || render.needsRender;
                }
                return needsRender;
            }), distinctUntilChanged((n1, n2) => {
                return n1 === n2;
            }, (co) => {
                return co.eraser.needsRender ||
                    co.trigger.needsRender ? -co.camera.frameId : co.camera.frameId;
            }))
                .subscribe((co) => {
                co.renderer.needsRender = false;
                co.camera.needsRender = false;
                co.eraser.needsRender = false;
                co.trigger.needsRender = false;
                const perspectiveCamera = co.camera.perspective;
                const backgroundRenders = [];
                const opaqueRenders = [];
                for (const render of co.renders) {
                    if (render.pass === RenderPass.Background) {
                        backgroundRenders.push(render.render);
                    }
                    else if (render.pass === RenderPass.Opaque) {
                        opaqueRenders.push(render.render);
                    }
                }
                const renderer = co.renderer.renderer;
                renderer.resetState();
                renderer.setClearColor(clearColor, 1.0);
                renderer.clear();
                for (const renderBackground of backgroundRenders) {
                    renderBackground(perspectiveCamera, renderer);
                }
                renderer.clearDepth();
                for (const renderOpaque of opaqueRenders) {
                    renderOpaque(perspectiveCamera, renderer);
                }
                renderer.resetState();
                this._opaqueRender$.next();
            });
            subs.push(renderSubscription);
            subs.push(this._renderFrame$.pipe(map((rc) => {
                return (irc) => {
                    irc.frameId = rc.frameId;
                    irc.perspective = rc.perspective;
                    if (rc.changed === true) {
                        irc.needsRender = true;
                    }
                    return irc;
                };
            }))
                .subscribe(this._renderCameraOperation$));
            this._renderFrameSubscribe();
            const renderHash$ = this._render$.pipe(map((hash) => {
                return (hashes) => {
                    hashes[hash.name] = hash.renderer;
                    return hashes;
                };
            }));
            const clearHash$ = this._clear$.pipe(map((name) => {
                return (hashes) => {
                    delete hashes[name];
                    return hashes;
                };
            }));
            subs.push(merge(renderHash$, clearHash$)
                .subscribe(this._renderOperation$));
            this._webGLRenderer$ = this._render$.pipe(first(), map(() => {
                canvasContainer.appendChild(canvas);
                const element = renderService.element;
                const webGLRenderer = new WebGLRenderer({ canvas: canvas });
                webGLRenderer.setPixelRatio(window.devicePixelRatio);
                webGLRenderer.setSize(element.offsetWidth, element.offsetHeight);
                webGLRenderer.autoClear = false;
                return webGLRenderer;
            }), publishReplay(1), refCount());
            subs.push(this._webGLRenderer$
                .subscribe(() => { }));
            const createRenderer$ = this._webGLRenderer$.pipe(first(), map((webGLRenderer) => {
                return (renderer) => {
                    renderer.needsRender = true;
                    renderer.renderer = webGLRenderer;
                    return renderer;
                };
            }));
            const resizeRenderer$ = this._renderService.size$.pipe(map((size) => {
                return (renderer) => {
                    if (renderer.renderer == null) {
                        return renderer;
                    }
                    renderer.renderer.setSize(size.width, size.height);
                    renderer.needsRender = true;
                    return renderer;
                };
            }));
            const clearRenderer$ = this._clear$.pipe(map(() => {
                return (renderer) => {
                    if (renderer.renderer == null) {
                        return renderer;
                    }
                    renderer.needsRender = true;
                    return renderer;
                };
            }));
            subs.push(merge(createRenderer$, resizeRenderer$, clearRenderer$)
                .subscribe(this._rendererOperation$));
            const renderCollectionEmpty$ = this._renderCollection$.pipe(filter((hashes) => {
                return Object.keys(hashes).length === 0;
            }), share());
            subs.push(renderCollectionEmpty$
                .subscribe(() => {
                if (this._renderFrameSubscription == null) {
                    return;
                }
                this._renderFrameSubscription.unsubscribe();
                this._renderFrameSubscription = null;
                this._renderFrameSubscribe();
            }));
            subs.push(renderCollectionEmpty$.pipe(map(() => {
                return (eraser) => {
                    eraser.needsRender = true;
                    return eraser;
                };
            }))
                .subscribe(this._eraserOperation$));
        }
        get render$() {
            return this._render$;
        }
        get opaqueRender$() {
            return this._opaqueRender$;
        }
        get webGLRenderer$() {
            return this._webGLRenderer$;
        }
        clear(name) {
            this._clear$.next(name);
        }
        remove() {
            this._rendererOperation$.next((renderer) => {
                if (renderer.renderer != null) {
                    const extension = renderer.renderer
                        .getContext()
                        .getExtension('WEBGL_lose_context');
                    if (!!extension) {
                        extension.loseContext();
                    }
                    renderer.renderer = null;
                }
                return renderer;
            });
            if (this._renderFrameSubscription != null) {
                this._renderFrameSubscription.unsubscribe();
            }
            this._subscriptions.unsubscribe();
        }
        triggerRerender() {
            this._renderService.renderCameraFrame$
                .pipe(skip(1), first())
                .subscribe(() => {
                this._triggerOperation$.next((trigger) => {
                    trigger.needsRender = true;
                    return trigger;
                });
            });
        }
        _renderFrameSubscribe() {
            this._render$.pipe(first(), map(() => {
                return (irc) => {
                    irc.needsRender = true;
                    return irc;
                };
            }))
                .subscribe((operation) => {
                this._renderCameraOperation$.next(operation);
            });
            this._renderFrameSubscription = this._render$.pipe(first(), mergeMap(() => {
                return this._renderService.renderCameraFrame$;
            }))
                .subscribe(this._renderFrame$);
        }
    }

    class RenderCamera {
        constructor(elementWidth, elementHeight, renderMode) {
            this._spatial = new Spatial();
            this._viewportCoords = new ViewportCoords();
            this._size = { width: elementWidth, height: elementHeight };
            this._initialFov = 60;
            this._alpha = -1;
            this._renderMode = renderMode;
            this._zoom = 0;
            this._frameId = -1;
            this._changed = false;
            this._changedForFrame = -1;
            this._currentImageId = null;
            this._previousImageId = null;
            this._currentSpherical = false;
            this._previousSpherical = false;
            this._state = null;
            this._currentProjectedPoints = [];
            this._previousProjectedPoints = [];
            this._currentFov = this._initialFov;
            this._previousFov = this._initialFov;
            this._camera = new Camera();
            this._perspective = new PerspectiveCamera(this._initialFov, this._computeAspect(elementWidth, elementHeight), 0.16, 10000);
            this._perspective.position.copy(this._camera.position);
            this._perspective.up.copy(this._camera.up);
            this._perspective.lookAt(this._camera.lookat);
            this._perspective.updateMatrixWorld(true);
            this._perspective.matrixAutoUpdate = false;
            this._rotation = { phi: 0, theta: 0 };
        }
        get alpha() {
            return this._alpha;
        }
        get camera() {
            return this._camera;
        }
        get changed() {
            return this._frameId === this._changedForFrame;
        }
        get frameId() {
            return this._frameId;
        }
        get perspective() {
            return this._perspective;
        }
        get renderMode() {
            return this._renderMode;
        }
        get rotation() {
            return this._rotation;
        }
        get zoom() {
            return this._zoom;
        }
        get size() {
            return this._size;
        }
        getTilt() {
            return 90 - this._spatial.radToDeg(this._rotation.theta);
        }
        fovToZoom(fov) {
            fov = Math.min(90, Math.max(0, fov));
            const currentFov = this._computeCurrentFov(0);
            const actualFov = this._alpha === 1 ?
                currentFov :
                this._interpolateFov(currentFov, this._computePreviousFov(0), this._alpha);
            const y0 = Math.tan(actualFov / 2 * Math.PI / 180);
            const y1 = Math.tan(fov / 2 * Math.PI / 180);
            const zoom = Math.log(y0 / y1) / Math.log(2);
            return zoom;
        }
        setFrame(frame) {
            const state = frame.state;
            if (state.state !== this._state) {
                this._state = state.state;
                if (this._state !== State.Custom) {
                    this.setRenderMode(this._renderMode);
                    this.setSize(this._size);
                }
                this._changed = true;
            }
            const currentImageId = state.currentImage.id;
            const previousImageId = !!state.previousImage ? state.previousImage.id : null;
            if (currentImageId !== this._currentImageId) {
                this._currentImageId = currentImageId;
                this._currentSpherical = isSpherical(state.currentTransform.cameraType);
                this._currentProjectedPoints = this._computeProjectedPoints(state.currentTransform);
                this._changed = true;
            }
            if (previousImageId !== this._previousImageId) {
                this._previousImageId = previousImageId;
                this._previousSpherical =
                    isSpherical(state.previousTransform.cameraType);
                this._previousProjectedPoints = this._computeProjectedPoints(state.previousTransform);
                this._changed = true;
            }
            const zoom = state.zoom;
            if (zoom !== this._zoom) {
                this._zoom = zoom;
                this._changed = true;
            }
            if (this._changed) {
                this._currentFov = this._computeCurrentFov(this.zoom);
                this._previousFov = this._computePreviousFov(this._zoom);
            }
            const alpha = state.alpha;
            if (this._changed || alpha !== this._alpha) {
                this._alpha = alpha;
                switch (this._state) {
                    case State.Earth:
                        this._perspective.fov = 60;
                        this._changed = true;
                        break;
                    case State.Custom:
                        break;
                    default:
                        this._perspective.fov =
                            this._interpolateFov(this._currentFov, this._previousFov, this._alpha);
                        this._changed = true;
                        break;
                }
                if (this._state !== State.Custom) {
                    this._perspective.updateProjectionMatrix();
                }
            }
            const camera = state.camera;
            if (this._camera.diff(camera) > 1e-9) {
                this._camera.copy(camera);
                this._rotation = this._computeRotation(camera);
                this._perspective.up.copy(camera.up);
                this._perspective.position.copy(camera.position);
                // Workaround for shaking camera
                this._perspective.matrixAutoUpdate = true;
                this._perspective.lookAt(camera.lookat);
                this._perspective.matrixAutoUpdate = false;
                this._perspective.updateMatrix();
                this._perspective.updateMatrixWorld(false);
                this._changed = true;
            }
            this._setFrameId(frame.id);
        }
        setProjectionMatrix(matrix) {
            this._perspective.projectionMatrix.fromArray(matrix);
            this._perspective.projectionMatrixInverse
                .copy(this._perspective.projectionMatrix)
                .invert();
            this._changed = true;
        }
        setRenderMode(renderMode) {
            this._renderMode = renderMode;
            if (this._state === State.Custom) {
                return;
            }
            this._perspective.fov = this._computeFov();
            this._perspective.updateProjectionMatrix();
            this._changed = true;
        }
        setSize(size) {
            this._size = size;
            if (this._state === State.Custom) {
                return;
            }
            this._perspective.aspect = this._computeAspect(size.width, size.height);
            this._perspective.fov = this._computeFov();
            this._perspective.updateProjectionMatrix();
            this._changed = true;
        }
        _computeAspect(elementWidth, elementHeight) {
            return elementWidth === 0 ? 0 : elementWidth / elementHeight;
        }
        _computeCurrentFov(zoom) {
            if (this._perspective.aspect === 0) {
                return 0;
            }
            if (!this._currentImageId) {
                return this._initialFov;
            }
            return this._currentSpherical ?
                this._yToFov(1, zoom) :
                this._computeVerticalFov(this._currentProjectedPoints, this._renderMode, zoom, this.perspective.aspect);
        }
        _computeFov() {
            this._currentFov = this._computeCurrentFov(this._zoom);
            this._previousFov = this._computePreviousFov(this._zoom);
            return this._interpolateFov(this._currentFov, this._previousFov, this._alpha);
        }
        _computePreviousFov(zoom) {
            if (this._perspective.aspect === 0) {
                return 0;
            }
            if (!this._currentImageId) {
                return this._initialFov;
            }
            return !this._previousImageId ?
                this._currentFov :
                this._previousSpherical ?
                    this._yToFov(1, zoom) :
                    this._computeVerticalFov(this._previousProjectedPoints, this._renderMode, zoom, this.perspective.aspect);
        }
        _computeProjectedPoints(transform) {
            const vertices = [[0.5, 0], [1, 0]];
            const directions = [[0.5, 0], [0, 0.5]];
            const pointsPerLine = 100;
            return computeProjectedPoints(transform, vertices, directions, pointsPerLine, this._viewportCoords);
        }
        _computeRequiredVerticalFov(projectedPoint, zoom, aspect) {
            const maxY = Math.max(projectedPoint[0] / aspect, projectedPoint[1]);
            return this._yToFov(maxY, zoom);
        }
        _computeRotation(camera) {
            let direction = camera.lookat.clone().sub(camera.position);
            let up = camera.up.clone();
            let phi = this._spatial.azimuthal(direction.toArray(), up.toArray());
            let theta = Math.PI / 2 - this._spatial.angleToPlane(direction.toArray(), [0, 0, 1]);
            return { phi: phi, theta: theta };
        }
        _computeVerticalFov(projectedPoints, renderMode, zoom, aspect) {
            const fovs = projectedPoints
                .map((projectedPoint) => {
                return this._computeRequiredVerticalFov(projectedPoint, zoom, aspect);
            });
            const fov = renderMode === exports.RenderMode.Fill ?
                Math.min(...fovs) * 0.995 :
                Math.max(...fovs);
            return fov;
        }
        _yToFov(y, zoom) {
            return 2 * Math.atan(y / Math.pow(2, zoom)) * 180 / Math.PI;
        }
        _interpolateFov(v1, v2, alpha) {
            return alpha * v1 + (1 - alpha) * v2;
        }
        _setFrameId(frameId) {
            this._frameId = frameId;
            if (this._changed) {
                this._changed = false;
                this._changedForFrame = frameId;
            }
        }
    }

    class RenderService {
        constructor(element, currentFrame$, renderMode, renderCamera) {
            this._subscriptions = new SubscriptionHolder();
            this._element = element;
            this._currentFrame$ = currentFrame$;
            this._spatial = new Spatial();
            renderMode = renderMode != null ? renderMode : exports.RenderMode.Fill;
            this._resize$ = new Subject();
            this._projectionMatrix$ = new Subject();
            this._renderCameraOperation$ =
                new Subject();
            this._size$ =
                new BehaviorSubject({
                    height: this._element.offsetHeight,
                    width: this._element.offsetWidth,
                });
            const subs = this._subscriptions;
            subs.push(this._resize$.pipe(map(() => {
                return {
                    height: this._element.offsetHeight,
                    width: this._element.offsetWidth,
                };
            }))
                .subscribe(this._size$));
            this._renderMode$ = new BehaviorSubject(renderMode);
            this._renderCameraHolder$ = this._renderCameraOperation$.pipe(startWith((rc) => {
                return rc;
            }), scan((rc, operation) => {
                return operation(rc);
            }, renderCamera !== null && renderCamera !== void 0 ? renderCamera : new RenderCamera(this._element.offsetWidth, this._element.offsetHeight, renderMode)), publishReplay(1), refCount());
            this._renderCameraFrame$ = this._currentFrame$.pipe(withLatestFrom(this._renderCameraHolder$), tap(([frame, rc]) => {
                rc.setFrame(frame);
            }), map((args) => {
                return args[1];
            }), publishReplay(1), refCount());
            this._renderCamera$ = this._renderCameraFrame$.pipe(filter((rc) => {
                return rc.changed;
            }), publishReplay(1), refCount());
            this._bearing$ = this._renderCamera$.pipe(map((rc) => {
                let bearing = this._spatial.radToDeg(this._spatial.azimuthalToBearing(rc.rotation.phi));
                return this._spatial.wrap(bearing, 0, 360);
            }), publishReplay(1), refCount());
            subs.push(this._size$.pipe(skip(1), map((size) => {
                return (rc) => {
                    rc.setSize(size);
                    return rc;
                };
            }))
                .subscribe(this._renderCameraOperation$));
            subs.push(this._renderMode$.pipe(skip(1), map((rm) => {
                return (rc) => {
                    rc.setRenderMode(rm);
                    return rc;
                };
            }))
                .subscribe(this._renderCameraOperation$));
            subs.push(this._projectionMatrix$.pipe(map((projectionMatrix) => {
                return (rc) => {
                    rc.setProjectionMatrix(projectionMatrix);
                    return rc;
                };
            }))
                .subscribe(this._renderCameraOperation$));
            subs.push(this._bearing$.subscribe(() => { }));
            subs.push(this._renderCameraHolder$.subscribe(() => { }));
            subs.push(this._size$.subscribe(() => { }));
            subs.push(this._renderMode$.subscribe(() => { }));
            subs.push(this._renderCamera$.subscribe(() => { }));
            subs.push(this._renderCameraFrame$.subscribe(() => { }));
        }
        get bearing$() {
            return this._bearing$;
        }
        get element() {
            return this._element;
        }
        get projectionMatrix$() {
            return this._projectionMatrix$;
        }
        get renderCamera$() {
            return this._renderCamera$;
        }
        get renderCameraFrame$() {
            return this._renderCameraFrame$;
        }
        get renderMode$() {
            return this._renderMode$;
        }
        get resize$() {
            return this._resize$;
        }
        get size$() {
            return this._size$;
        }
        dispose() {
            this._subscriptions.unsubscribe();
        }
    }

    class KeyboardService {
        constructor(canvasContainer) {
            this._keyDown$ = fromEvent(canvasContainer, "keydown");
            this._keyUp$ = fromEvent(canvasContainer, "keyup");
        }
        get keyDown$() {
            return this._keyDown$;
        }
        get keyUp$() {
            return this._keyUp$;
        }
    }

    // MouseEvent.button
    const LEFT_BUTTON = 0;
    const RIGHT_BUTTON = 2;
    // MouseEvent.buttons
    const BUTTONS_MAP = {
        [LEFT_BUTTON]: 1,
        [RIGHT_BUTTON]: 2
    };
    class MouseService {
        constructor(container, canvasContainer, domContainer, doc) {
            this._subscriptions = new SubscriptionHolder();
            const subs = this._subscriptions;
            this._activeSubject$ = new BehaviorSubject(false);
            this._active$ = this._activeSubject$
                .pipe(distinctUntilChanged(), publishReplay(1), refCount());
            this._claimMouse$ = new Subject();
            this._claimWheel$ = new Subject();
            this._deferPixelClaims$ = new Subject();
            this._deferPixels$ = this._deferPixelClaims$
                .pipe(scan((claims, claim) => {
                if (claim.deferPixels == null) {
                    delete claims[claim.name];
                }
                else {
                    claims[claim.name] = claim.deferPixels;
                }
                return claims;
            }, {}), map((claims) => {
                let deferPixelMax = -1;
                for (const key in claims) {
                    if (!claims.hasOwnProperty(key)) {
                        continue;
                    }
                    const deferPixels = claims[key];
                    if (deferPixels > deferPixelMax) {
                        deferPixelMax = deferPixels;
                    }
                }
                return deferPixelMax;
            }), startWith(-1), publishReplay(1), refCount());
            subs.push(this._deferPixels$.subscribe(() => { }));
            this._documentMouseMove$ =
                fromEvent(doc, "pointermove")
                    .pipe(filter(this._isMousePen));
            this._documentMouseUp$ =
                fromEvent(doc, "pointerup")
                    .pipe(filter(this._isMousePen));
            this._mouseDown$ =
                fromEvent(canvasContainer, "pointerdown")
                    .pipe(filter(this._isMousePen));
            this._mouseEnter$ =
                fromEvent(canvasContainer, "pointerenter")
                    .pipe(filter(this._isMousePen));
            this._mouseLeave$ =
                fromEvent(canvasContainer, "pointerleave")
                    .pipe(filter(this._isMousePen));
            this._mouseMove$ =
                fromEvent(canvasContainer, "pointermove")
                    .pipe(filter(this._isMousePen));
            this._mouseUp$ =
                fromEvent(canvasContainer, "pointerup")
                    .pipe(filter(this._isMousePen));
            this._mouseOut$ =
                fromEvent(canvasContainer, "pointerout")
                    .pipe(filter(this._isMousePen));
            this._mouseOver$ =
                fromEvent(canvasContainer, "pointerover")
                    .pipe(filter(this._isMousePen));
            this._domMouseDown$ =
                fromEvent(domContainer, "pointerdown")
                    .pipe(filter(this._isMousePen));
            this._domMouseMove$ =
                fromEvent(domContainer, "pointermove")
                    .pipe(filter(this._isMousePen));
            this._click$ =
                fromEvent(canvasContainer, "click");
            this._contextMenu$ =
                fromEvent(canvasContainer, "contextmenu");
            this._windowBlur$ =
                fromEvent(window, "blur");
            this._dblClick$ = merge(fromEvent(container, "click"), fromEvent(canvasContainer, "dblclick"))
                .pipe(bufferCount(3, 1), filter((events) => {
                const event1 = events[0];
                const event2 = events[1];
                const event3 = events[2];
                return event1.type === "click" &&
                    event2.type === "click" &&
                    event3.type === "dblclick" &&
                    event1.target.parentNode === canvasContainer &&
                    event2.target.parentNode === canvasContainer;
            }), map((events) => {
                return events[2];
            }), share());
            subs.push(merge(this._domMouseDown$, this._domMouseMove$, this._dblClick$, this._contextMenu$)
                .subscribe((event) => {
                event.preventDefault();
            }));
            this._mouseWheel$ = merge(fromEvent(canvasContainer, "wheel"), fromEvent(domContainer, "wheel"))
                .pipe(share());
            this._consistentContextMenu$ =
                merge(this._mouseDown$, this._mouseMove$, this._mouseOut$, this._mouseUp$, this._contextMenu$)
                    .pipe(bufferCount(3, 1), filter((events) => {
                    // fire context menu on mouse up both on mac and windows
                    return events[0].type === "pointerdown" &&
                        events[1].type === "contextmenu" &&
                        events[2].type === "pointerup";
                }), map((events) => {
                    return events[1];
                }), share());
            const dragStop$ = merge(this._windowBlur$, this._documentMouseMove$
                .pipe(filter((e) => {
                return this._buttonReleased(e, LEFT_BUTTON);
            })), this._documentMouseUp$
                .pipe(filter((e) => {
                return this._mouseButton(e) === LEFT_BUTTON;
            })))
                .pipe(share());
            const mouseDragInitiate$ = this._createMouseDragInitiate$(LEFT_BUTTON, this._mouseDown$, dragStop$, true)
                .pipe(share());
            this._mouseDragStart$ =
                this._createMouseDragStart$(mouseDragInitiate$)
                    .pipe(share());
            this._mouseDrag$ =
                this._createMouseDrag$(mouseDragInitiate$, dragStop$)
                    .pipe(share());
            this._mouseDragEnd$ =
                this._createMouseDragEnd$(this._mouseDragStart$, dragStop$)
                    .pipe(share());
            const domMouseDragInitiate$ = this._createMouseDragInitiate$(LEFT_BUTTON, this._domMouseDown$, dragStop$, false)
                .pipe(share());
            this._domMouseDragStart$ =
                this._createMouseDragStart$(domMouseDragInitiate$)
                    .pipe(share());
            this._domMouseDrag$ =
                this._createMouseDrag$(domMouseDragInitiate$, dragStop$)
                    .pipe(share());
            this._domMouseDragEnd$ =
                this._createMouseDragEnd$(this._domMouseDragStart$, dragStop$)
                    .pipe(share());
            const rightDragStop$ = merge(this._windowBlur$, this._documentMouseMove$.pipe(filter((e) => {
                return this._buttonReleased(e, RIGHT_BUTTON);
            })), this._documentMouseUp$.pipe(filter((e) => {
                return this._mouseButton(e) === RIGHT_BUTTON;
            })))
                .pipe(share());
            const mouseRightDragInitiate$ = this._createMouseDragInitiate$(RIGHT_BUTTON, this._mouseDown$, rightDragStop$, true)
                .pipe(share());
            this._mouseRightDragStart$ =
                this._createMouseDragStart$(mouseRightDragInitiate$)
                    .pipe(share());
            this._mouseRightDrag$ =
                this._createMouseDrag$(mouseRightDragInitiate$, rightDragStop$)
                    .pipe(share());
            this._mouseRightDragEnd$ =
                this._createMouseDragEnd$(this._mouseRightDragStart$, rightDragStop$)
                    .pipe(share());
            this._proximateClick$ = this._mouseDown$
                .pipe(switchMap((mouseDown) => {
                return this._click$.pipe(takeUntil(this._createDeferredMouseMove$(mouseDown, this._documentMouseMove$)), take(1));
            }), share());
            this._staticClick$ = this._mouseDown$
                .pipe(switchMap(() => {
                return this._click$.pipe(takeUntil(this._documentMouseMove$), take(1));
            }), share());
            subs.push(this._mouseDragStart$.subscribe());
            subs.push(this._mouseDrag$.subscribe());
            subs.push(this._mouseDragEnd$.subscribe());
            subs.push(this._domMouseDragStart$.subscribe());
            subs.push(this._domMouseDrag$.subscribe());
            subs.push(this._domMouseDragEnd$.subscribe());
            subs.push(this._mouseRightDragStart$.subscribe());
            subs.push(this._mouseRightDrag$.subscribe());
            subs.push(this._mouseRightDragEnd$.subscribe());
            subs.push(this._staticClick$.subscribe());
            this._mouseOwner$ = this._createOwner$(this._claimMouse$)
                .pipe(publishReplay(1), refCount());
            this._wheelOwner$ = this._createOwner$(this._claimWheel$)
                .pipe(publishReplay(1), refCount());
            subs.push(this._mouseOwner$.subscribe(() => { }));
            subs.push(this._wheelOwner$.subscribe(() => { }));
        }
        get active$() {
            return this._active$;
        }
        get activate$() {
            return this._activeSubject$;
        }
        get documentMouseMove$() {
            return this._documentMouseMove$;
        }
        get documentMouseUp$() {
            return this._documentMouseUp$;
        }
        get domMouseDragStart$() {
            return this._domMouseDragStart$;
        }
        get domMouseDrag$() {
            return this._domMouseDrag$;
        }
        get domMouseDragEnd$() {
            return this._domMouseDragEnd$;
        }
        get domMouseDown$() {
            return this._domMouseDown$;
        }
        get domMouseMove$() {
            return this._domMouseMove$;
        }
        get mouseOwner$() {
            return this._mouseOwner$;
        }
        get mouseDown$() {
            return this._mouseDown$;
        }
        get mouseEnter$() {
            return this._mouseEnter$;
        }
        get mouseMove$() {
            return this._mouseMove$;
        }
        get mouseLeave$() {
            return this._mouseLeave$;
        }
        get mouseOut$() {
            return this._mouseOut$;
        }
        get mouseOver$() {
            return this._mouseOver$;
        }
        get mouseUp$() {
            return this._mouseUp$;
        }
        get click$() {
            return this._click$;
        }
        get dblClick$() {
            return this._dblClick$;
        }
        get contextMenu$() {
            return this._consistentContextMenu$;
        }
        get mouseWheel$() {
            return this._mouseWheel$;
        }
        get mouseDragStart$() {
            return this._mouseDragStart$;
        }
        get mouseDrag$() {
            return this._mouseDrag$;
        }
        get mouseDragEnd$() {
            return this._mouseDragEnd$;
        }
        get mouseRightDragStart$() {
            return this._mouseRightDragStart$;
        }
        get mouseRightDrag$() {
            return this._mouseRightDrag$;
        }
        get mouseRightDragEnd$() {
            return this._mouseRightDragEnd$;
        }
        get proximateClick$() {
            return this._proximateClick$;
        }
        get staticClick$() {
            return this._staticClick$;
        }
        get windowBlur$() {
            return this._windowBlur$;
        }
        dispose() {
            this._subscriptions.unsubscribe();
        }
        claimMouse(name, zindex) {
            this._claimMouse$.next({ name: name, zindex: zindex });
        }
        unclaimMouse(name) {
            this._claimMouse$.next({ name: name, zindex: null });
        }
        deferPixels(name, deferPixels) {
            this._deferPixelClaims$.next({ name: name, deferPixels: deferPixels });
        }
        undeferPixels(name) {
            this._deferPixelClaims$.next({ name: name, deferPixels: null });
        }
        claimWheel(name, zindex) {
            this._claimWheel$.next({ name: name, zindex: zindex });
        }
        unclaimWheel(name) {
            this._claimWheel$.next({ name: name, zindex: null });
        }
        filtered$(name, observable$) {
            return this._filtered(name, observable$, this._mouseOwner$);
        }
        filteredWheel$(name, observable$) {
            return this._filtered(name, observable$, this._wheelOwner$);
        }
        _createDeferredMouseMove$(origin, mouseMove$) {
            return mouseMove$.pipe(map((mouseMove) => {
                const deltaX = mouseMove.clientX - origin.clientX;
                const deltaY = mouseMove.clientY - origin.clientY;
                return [mouseMove, Math.sqrt(deltaX * deltaX + deltaY * deltaY)];
            }), withLatestFrom(this._deferPixels$), filter(([[, delta], deferPixels]) => {
                return delta > deferPixels;
            }), map(([[mouseMove]]) => {
                return mouseMove;
            }));
        }
        _createMouseDrag$(mouseDragStartInitiate$, stop$) {
            return mouseDragStartInitiate$.pipe(map(([, mouseMove]) => {
                return mouseMove;
            }), switchMap((mouseMove) => {
                return concat(of(mouseMove), this._documentMouseMove$).pipe(takeUntil(stop$));
            }));
        }
        _createMouseDragEnd$(mouseDragStart$, stop$) {
            return mouseDragStart$.pipe(switchMap(() => {
                return stop$.pipe(first());
            }));
        }
        _createMouseDragStart$(mouseDragStartInitiate$) {
            return mouseDragStartInitiate$.pipe(map(([mouseDown]) => {
                return mouseDown;
            }));
        }
        _createMouseDragInitiate$(button, mouseDown$, stop$, defer) {
            return mouseDown$.pipe(filter((mouseDown) => {
                return this._mouseButton(mouseDown) === button;
            }), switchMap((mouseDown) => {
                return combineLatest(of(mouseDown), defer ?
                    this._createDeferredMouseMove$(mouseDown, this._documentMouseMove$) :
                    this._documentMouseMove$).pipe(takeUntil(stop$), take(1));
            }));
        }
        _createOwner$(claim$) {
            return claim$.pipe(scan((claims, claim) => {
                if (claim.zindex == null) {
                    delete claims[claim.name];
                }
                else {
                    claims[claim.name] = claim.zindex;
                }
                return claims;
            }, {}), map((claims) => {
                let owner = null;
                let zIndexMax = -1;
                for (const name in claims) {
                    if (!claims.hasOwnProperty(name)) {
                        continue;
                    }
                    if (claims[name] > zIndexMax) {
                        zIndexMax = claims[name];
                        owner = name;
                    }
                }
                return owner;
            }), startWith(null));
        }
        _filtered(name, observable$, owner$) {
            return observable$.pipe(withLatestFrom(owner$), filter(([, owner]) => {
                return owner === name;
            }), map(([item]) => {
                return item;
            }));
        }
        _mouseButton(event) {
            const upOrDown = event.type === "pointerdown" || event.type === "pointerup";
            const InstallTrigger = window.InstallTrigger;
            if (upOrDown &&
                typeof InstallTrigger !== 'undefined' &&
                event.button === RIGHT_BUTTON && event.ctrlKey &&
                window.navigator.platform.toUpperCase().indexOf('MAC') >= 0) {
                // Fix for the fact that Firefox (detected by InstallTrigger)
                // on Mac determines e.button = 2 when using Control + left click.
                return LEFT_BUTTON;
            }
            return event.button;
        }
        _buttonReleased(event, button) {
            // Right button `mouseup` is not fired in
            // Chrome on Mac outside the window or iframe. If
            // the button is no longer pressed during move
            // it may have been released and drag stop
            // should be emitted.
            const flag = BUTTONS_MAP[button];
            return event.buttons === undefined || (event.buttons & flag) !== flag;
        }
        _isMousePen(event) {
            const type = event.pointerType;
            return type === "mouse" || type === "pen";
        }
    }

    class SpriteAtlas {
        set json(value) {
            this._json = value;
        }
        set image(value) {
            this._image = value;
            this._texture = new Texture(this._image);
            this._texture.minFilter = NearestFilter;
        }
        get loaded() {
            return !!(this._image && this._json);
        }
        getGLSprite(name) {
            if (!this.loaded) {
                throw new Error("Sprites cannot be retrieved before the atlas is loaded.");
            }
            let definition = this._json[name];
            if (!definition) {
                console.warn("Sprite with key" + name + "does not exist in sprite definition.");
                return new Object3D();
            }
            let texture = this._texture.clone();
            texture.needsUpdate = true;
            let width = this._image.width;
            let height = this._image.height;
            texture.offset.x = definition.x / width;
            texture.offset.y = (height - definition.y - definition.height) / height;
            texture.repeat.x = definition.width / width;
            texture.repeat.y = definition.height / height;
            let material = new SpriteMaterial({ map: texture });
            return new Sprite(material);
        }
        getDOMSprite(name, float) {
            if (!this.loaded) {
                throw new Error("Sprites cannot be retrieved before the atlas is loaded.");
            }
            if (float == null) {
                float = exports.Alignment.Center;
            }
            let definition = this._json[name];
            if (!definition) {
                console.warn("Sprite with key" + name + "does not exist in sprite definition.");
                return virtualDom.h("div", {}, []);
            }
            let clipTop = definition.y;
            let clipRigth = definition.x + definition.width;
            let clipBottom = definition.y + definition.height;
            let clipLeft = definition.x;
            let left = -definition.x;
            let top = -definition.y;
            let height = this._image.height;
            let width = this._image.width;
            switch (float) {
                case exports.Alignment.Bottom:
                case exports.Alignment.Center:
                case exports.Alignment.Top:
                    left -= definition.width / 2;
                    break;
                case exports.Alignment.BottomLeft:
                case exports.Alignment.Left:
                case exports.Alignment.TopLeft:
                    left -= definition.width;
                    break;
                case exports.Alignment.BottomRight:
                case exports.Alignment.Right:
                case exports.Alignment.TopRight:
            }
            switch (float) {
                case exports.Alignment.Center:
                case exports.Alignment.Left:
                case exports.Alignment.Right:
                    top -= definition.height / 2;
                    break;
                case exports.Alignment.Top:
                case exports.Alignment.TopLeft:
                case exports.Alignment.TopRight:
                    top -= definition.height;
                    break;
                case exports.Alignment.Bottom:
                case exports.Alignment.BottomLeft:
                case exports.Alignment.BottomRight:
            }
            let pixelRatioInverse = 1 / definition.pixelRatio;
            clipTop *= pixelRatioInverse;
            clipRigth *= pixelRatioInverse;
            clipBottom *= pixelRatioInverse;
            clipLeft *= pixelRatioInverse;
            left *= pixelRatioInverse;
            top *= pixelRatioInverse;
            height *= pixelRatioInverse;
            width *= pixelRatioInverse;
            let properties = {
                src: this._image.src,
                style: {
                    clip: `rect(${clipTop}px, ${clipRigth}px, ${clipBottom}px, ${clipLeft}px)`,
                    height: `${height}px`,
                    left: `${left}px`,
                    position: "absolute",
                    top: `${top}px`,
                    width: `${width}px`,
                },
            };
            return virtualDom.h("img", properties, []);
        }
    }
    class SpriteService {
        constructor(sprite) {
            this._retina = window.devicePixelRatio > 1;
            this._spriteAtlasOperation$ = new Subject();
            this._spriteAtlas$ = this._spriteAtlasOperation$.pipe(startWith((atlas) => {
                return atlas;
            }), scan((atlas, operation) => {
                return operation(atlas);
            }, new SpriteAtlas()), publishReplay(1), refCount());
            this._atlasSubscription = this._spriteAtlas$
                .subscribe(() => { });
            if (sprite == null) {
                return;
            }
            let format = this._retina ? "@2x" : "";
            let imageXmlHTTP = new XMLHttpRequest();
            imageXmlHTTP.open("GET", sprite + format + ".png", true);
            imageXmlHTTP.responseType = "arraybuffer";
            imageXmlHTTP.onload = () => {
                let image = new Image();
                image.onload = () => {
                    this._spriteAtlasOperation$.next((atlas) => {
                        atlas.image = image;
                        return atlas;
                    });
                };
                let blob = new Blob([imageXmlHTTP.response]);
                image.src = window.URL.createObjectURL(blob);
            };
            imageXmlHTTP.onerror = (error) => {
                console.error(new Error(`Failed to fetch sprite sheet (${sprite}${format}.png)`));
            };
            imageXmlHTTP.send();
            let jsonXmlHTTP = new XMLHttpRequest();
            jsonXmlHTTP.open("GET", sprite + format + ".json", true);
            jsonXmlHTTP.responseType = "text";
            jsonXmlHTTP.onload = () => {
                let json = JSON.parse(jsonXmlHTTP.response);
                this._spriteAtlasOperation$.next((atlas) => {
                    atlas.json = json;
                    return atlas;
                });
            };
            jsonXmlHTTP.onerror = (error) => {
                console.error(new Error(`Failed to fetch sheet (${sprite}${format}.json)`));
            };
            jsonXmlHTTP.send();
        }
        get spriteAtlas$() {
            return this._spriteAtlas$;
        }
        dispose() {
            this._atlasSubscription.unsubscribe();
        }
    }

    class TouchService {
        constructor(canvasContainer, domContainer) {
            this._subscriptions = new SubscriptionHolder();
            const subs = this._subscriptions;
            this._activeSubject$ = new BehaviorSubject(false);
            this._active$ = this._activeSubject$.pipe(distinctUntilChanged(), publishReplay(1), refCount());
            subs.push(fromEvent(domContainer, "touchmove")
                .subscribe((event) => {
                event.preventDefault();
            }));
            this._touchStart$ = fromEvent(canvasContainer, "touchstart");
            this._touchMove$ = fromEvent(canvasContainer, "touchmove");
            this._touchEnd$ = fromEvent(canvasContainer, "touchend");
            this._touchCancel$ = fromEvent(canvasContainer, "touchcancel");
            const tapStart$ = this._touchStart$.pipe(filter((te) => {
                return te.touches.length === 1 && te.targetTouches.length === 1;
            }), share());
            this._doubleTap$ = tapStart$.pipe(bufferWhen(() => {
                return tapStart$.pipe(first(), switchMap(() => {
                    return merge(timer(300), tapStart$).pipe(take(1));
                }));
            }), filter((events) => {
                return events.length === 2;
            }), map((events) => {
                return events[events.length - 1];
            }), share());
            subs.push(this._doubleTap$
                .subscribe((event) => {
                event.preventDefault();
            }));
            this._singleTouchMove$ = this._touchMove$.pipe(filter((te) => {
                return te.touches.length === 1 && te.targetTouches.length === 1;
            }), share());
            let singleTouchStart$ = merge(this._touchStart$, this._touchEnd$, this._touchCancel$).pipe(filter((te) => {
                return te.touches.length === 1 && te.targetTouches.length === 1;
            }));
            let multipleTouchStart$ = merge(this._touchStart$, this._touchEnd$, this._touchCancel$).pipe(filter((te) => {
                return te.touches.length >= 1;
            }));
            let touchStop$ = merge(this._touchEnd$, this._touchCancel$).pipe(filter((te) => {
                return te.touches.length === 0;
            }));
            this._singleTouchDragStart$ = singleTouchStart$.pipe(mergeMap(() => {
                return this._singleTouchMove$.pipe(takeUntil(merge(touchStop$, multipleTouchStart$)), take(1));
            }));
            this._singleTouchDragEnd$ = singleTouchStart$.pipe(mergeMap(() => {
                return merge(touchStop$, multipleTouchStart$).pipe(first());
            }));
            this._singleTouchDrag$ = singleTouchStart$.pipe(switchMap(() => {
                return this._singleTouchMove$.pipe(skip(1), takeUntil(merge(multipleTouchStart$, touchStop$)));
            }));
            let touchesChanged$ = merge(this._touchStart$, this._touchEnd$, this._touchCancel$);
            this._pinchStart$ = touchesChanged$.pipe(filter((te) => {
                return te.touches.length === 2 && te.targetTouches.length === 2;
            }));
            this._pinchEnd$ = touchesChanged$.pipe(filter((te) => {
                return te.touches.length !== 2 || te.targetTouches.length !== 2;
            }));
            this._pinchOperation$ = new Subject();
            this._pinch$ = this._pinchOperation$.pipe(scan((pinch, operation) => {
                return operation(pinch);
            }, {
                changeX: 0,
                changeY: 0,
                clientX: 0,
                clientY: 0,
                distance: 0,
                distanceChange: 0,
                distanceX: 0,
                distanceY: 0,
                originalEvent: null,
                pageX: 0,
                pageY: 0,
                screenX: 0,
                screenY: 0,
                touch1: null,
                touch2: null,
            }));
            const pinchSubscription = this._touchMove$.pipe(filter((te) => {
                return te.touches.length === 2 && te.targetTouches.length === 2;
            }), map((te) => {
                return (previous) => {
                    let touch1 = te.touches[0];
                    let touch2 = te.touches[1];
                    let minX = Math.min(touch1.clientX, touch2.clientX);
                    let maxX = Math.max(touch1.clientX, touch2.clientX);
                    let minY = Math.min(touch1.clientY, touch2.clientY);
                    let maxY = Math.max(touch1.clientY, touch2.clientY);
                    let centerClientX = minX + (maxX - minX) / 2;
                    let centerClientY = minY + (maxY - minY) / 2;
                    let centerPageX = centerClientX + touch1.pageX - touch1.clientX;
                    let centerPageY = centerClientY + touch1.pageY - touch1.clientY;
                    let centerScreenX = centerClientX + touch1.screenX - touch1.clientX;
                    let centerScreenY = centerClientY + touch1.screenY - touch1.clientY;
                    let distanceX = Math.abs(touch1.clientX - touch2.clientX);
                    let distanceY = Math.abs(touch1.clientY - touch2.clientY);
                    let distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY);
                    let distanceChange = distance - previous.distance;
                    let changeX = distanceX - previous.distanceX;
                    let changeY = distanceY - previous.distanceY;
                    let current = {
                        changeX: changeX,
                        changeY: changeY,
                        clientX: centerClientX,
                        clientY: centerClientY,
                        distance: distance,
                        distanceChange: distanceChange,
                        distanceX: distanceX,
                        distanceY: distanceY,
                        originalEvent: te,
                        pageX: centerPageX,
                        pageY: centerPageY,
                        screenX: centerScreenX,
                        screenY: centerScreenY,
                        touch1: touch1,
                        touch2: touch2,
                    };
                    return current;
                };
            }))
                .subscribe(this._pinchOperation$);
            subs.push(pinchSubscription);
            this._pinchChange$ = this._pinchStart$.pipe(switchMap(() => {
                return this._pinch$.pipe(skip(1), takeUntil(this._pinchEnd$));
            }));
        }
        get active$() {
            return this._active$;
        }
        get activate$() {
            return this._activeSubject$;
        }
        get doubleTap$() {
            return this._doubleTap$;
        }
        get touchStart$() {
            return this._touchStart$;
        }
        get touchMove$() {
            return this._touchMove$;
        }
        get touchEnd$() {
            return this._touchEnd$;
        }
        get touchCancel$() {
            return this._touchCancel$;
        }
        get singleTouchDragStart$() {
            return this._singleTouchDragStart$;
        }
        get singleTouchDrag$() {
            return this._singleTouchDrag$;
        }
        get singleTouchDragEnd$() {
            return this._singleTouchDragEnd$;
        }
        get pinch$() {
            return this._pinchChange$;
        }
        get pinchStart$() {
            return this._pinchStart$;
        }
        get pinchEnd$() {
            return this._pinchEnd$;
        }
        dispose() {
            this._subscriptions.unsubscribe();
        }
    }

    class ConfigurationService {
        constructor(options) {
            var _a, _b, _c, _d;
            const host = (_b = (_a = options === null || options === void 0 ? void 0 : options.url) === null || _a === void 0 ? void 0 : _a.exploreHost) !== null && _b !== void 0 ? _b : "www.mapillary.com";
            const scheme = (_d = (_c = options === null || options === void 0 ? void 0 : options.url) === null || _c === void 0 ? void 0 : _c.scheme) !== null && _d !== void 0 ? _d : "https";
            const exploreUrl = `${scheme}://${host}`;
            this._exploreUrl$ = of(exploreUrl);
            const imageTiling = (options === null || options === void 0 ? void 0 : options.imageTiling) === false ? false : true;
            this._imageTiling$ = of(imageTiling);
        }
        get exploreUrl$() {
            return this._exploreUrl$;
        }
        get imageTiling$() {
            return this._imageTiling$;
        }
    }

    class Container {
        constructor(options, stateService, dom) {
            var _a;
            this._onWindowResize = () => {
                if (this._trackResize) {
                    this.renderService.resize$.next();
                }
            };
            this._dom = dom !== null && dom !== void 0 ? dom : new DOM();
            if (typeof options.container === "string") {
                this._container = this._dom.document
                    .getElementById(options.container);
                if (!this._container) {
                    throw new Error(`Container "${options.container}" not found.`);
                }
            }
            else if (options.container instanceof HTMLElement) {
                this._container = options.container;
            }
            else {
                throw new Error(`Invalid type: "container" must be ` +
                    `a String or HTMLElement.`);
            }
            this._trackResize =
                options.trackResize === false ?
                    false : true;
            this.id = (_a = this._container.id) !== null && _a !== void 0 ? _a : "mapillary-fallback-container-id";
            this._container.classList
                .add("mapillary-viewer");
            this._canvasContainer = this._dom
                .createElement("div", "mapillary-interactive", this._container);
            this._canvas = this._dom
                .createElement("canvas", "mapillary-canvas");
            this._canvas.style.position = "absolute";
            this._canvas.setAttribute("tabindex", "0");
            // Add DOM container after canvas container to
            // render DOM elements on top of the interactive
            // canvas.
            this._domContainer = this._dom
                .createElement("div", "mapillary-dom", this._container);
            this.configurationService = new ConfigurationService(options);
            this.renderService =
                new RenderService(this._container, stateService.currentState$, options.renderMode);
            this.glRenderer =
                new GLRenderer(this._canvas, this._canvasContainer, this.renderService);
            this.domRenderer =
                new DOMRenderer(this._domContainer, this.renderService, stateService.currentState$);
            this.keyboardService =
                new KeyboardService(this._canvasContainer);
            this.mouseService =
                new MouseService(this._container, this._canvasContainer, this._domContainer, document);
            this.touchService =
                new TouchService(this._canvasContainer, this._domContainer);
            this.spriteService =
                new SpriteService(options.sprite);
            window.addEventListener('resize', this._onWindowResize, false);
        }
        get canvas() {
            return !!this._canvas.parentNode ?
                this._canvas : null;
        }
        get canvasContainer() {
            return this._canvasContainer;
        }
        get container() {
            return this._container;
        }
        get domContainer() {
            return this._domContainer;
        }
        remove() {
            window.removeEventListener('resize', this._onWindowResize, false);
            this.spriteService.dispose();
            this.touchService.dispose();
            this.mouseService.dispose();
            this.glRenderer.remove();
            this.domRenderer.remove();
            this.renderService.dispose();
            this._removeNode(this._canvasContainer);
            this._removeNode(this._domContainer);
            this._container.classList
                .remove("mapillary-viewer");
        }
        _removeNode(node) {
            if (node.parentNode) {
                node.parentNode.removeChild(node);
            }
        }
    }

    class CacheService {
        constructor(_graphService, _stateService, _api) {
            this._graphService = _graphService;
            this._stateService = _stateService;
            this._api = _api;
            this._subscriptions = new SubscriptionHolder();
            this._started = false;
            this._cellDepth = 1;
        }
        get started() {
            return this._started;
        }
        configure(configuration) {
            if (!configuration) {
                this._cellDepth = 1;
                return;
            }
            this._cellDepth = Math.max(1, Math.min(3, configuration.cellDepth));
        }
        start() {
            if (this._started) {
                return;
            }
            const subs = this._subscriptions;
            subs.push(this._stateService.currentState$
                .pipe(distinctUntilChanged(undefined, (frame) => {
                return frame.state.currentImage.id;
            }), map((frame) => {
                const state = frame.state;
                const trajectory = state.trajectory;
                const trajectoryKeys = trajectory
                    .map((n) => {
                    return n.id;
                });
                const sequenceKey = trajectory[trajectory.length - 1].sequenceId;
                return [
                    trajectoryKeys,
                    state.currentImage.originalLngLat,
                    sequenceKey,
                ];
            }), bufferCount(1, 5), withLatestFrom(this._graphService.graphMode$), switchMap(([keepBuffer, graphMode]) => {
                const keepKeys = keepBuffer[0][0];
                const lngLat = keepBuffer[0][1];
                const geometry = this._api.data.geometry;
                const cellId = geometry.lngLatToCellId(lngLat);
                const keepCellIds = connectedComponent(cellId, this._cellDepth, geometry);
                const keepSequenceKey = graphMode === GraphMode.Sequence ?
                    keepBuffer[0][2] :
                    undefined;
                return this._graphService
                    .uncache$(keepKeys, keepCellIds, keepSequenceKey);
            }))
                .subscribe(() => { }));
            subs.push(this._graphService.graphMode$
                .pipe(skip(1), withLatestFrom(this._stateService.currentState$), switchMap(([mode, frame]) => {
                return mode === GraphMode.Sequence ?
                    this._keyToEdges(frame.state.currentImage.id, (image) => {
                        return image.sequenceEdges$;
                    }) :
                    from(frame.state.trajectory
                        .map((image) => {
                        return image.id;
                    })
                        .slice(frame.state.currentIndex)).pipe(mergeMap((key) => {
                        return this._keyToEdges(key, (image) => {
                            return image.spatialEdges$;
                        });
                    }, 6));
            }))
                .subscribe(() => { }));
            subs.push(this._graphService.dataAdded$
                .pipe(withLatestFrom(this._stateService.currentId$), switchMap(([_, imageId]) => {
                return this._graphService.cacheImage$(imageId);
            }))
                .subscribe(() => { }));
            this._started = true;
        }
        stop() {
            if (!this._started) {
                return;
            }
            this._subscriptions.unsubscribe();
            this._started = false;
        }
        _keyToEdges(key, imageToEdgeMap) {
            return this._graphService.cacheImage$(key).pipe(switchMap(imageToEdgeMap), first((status) => {
                return status.cached;
            }), timeout(15000), catchError((error) => {
                console.error(`Failed to cache edges (${key}).`, error);
                return empty();
            }));
        }
    }

    class LoadingService {
        constructor() {
            this._loadersSubject$ = new Subject();
            this._loaders$ = this._loadersSubject$.pipe(scan((loaders, loader) => {
                if (loader.task !== undefined) {
                    loaders[loader.task] = loader.loading;
                }
                return loaders;
            }, {}), startWith({}), publishReplay(1), refCount());
        }
        get loading$() {
            return this._loaders$.pipe(map((loaders) => {
                for (const key in loaders) {
                    if (!loaders.hasOwnProperty(key)) {
                        continue;
                    }
                    if (loaders[key]) {
                        return true;
                    }
                }
                return false;
            }), debounceTime(100), distinctUntilChanged());
        }
        taskLoading$(task) {
            return this._loaders$.pipe(map((loaders) => {
                return !!loaders[task];
            }), debounceTime(100), distinctUntilChanged());
        }
        startLoading(task) {
            this._loadersSubject$.next({ loading: true, task: task });
        }
        stopLoading(task) {
            this._loadersSubject$.next({ loading: false, task: task });
        }
    }

    var PanMode;
    (function (PanMode) {
        PanMode[PanMode["Disabled"] = 0] = "Disabled";
        PanMode[PanMode["Enabled"] = 1] = "Enabled";
        PanMode[PanMode["Started"] = 2] = "Started";
    })(PanMode || (PanMode = {}));
    class PanService {
        constructor(graphService, stateService, enabled, graphCalculator, spatial, viewportCoords) {
            this._subscriptions = new SubscriptionHolder();
            this._graphService = graphService;
            this._stateService = stateService;
            this._graphCalculator = graphCalculator !== null && graphCalculator !== void 0 ? graphCalculator : new GraphCalculator();
            this._spatial = spatial !== null && spatial !== void 0 ? spatial : new Spatial();
            this._viewportCoords = viewportCoords !== null && viewportCoords !== void 0 ? viewportCoords : new ViewportCoords();
            this._mode = enabled !== false ?
                PanMode.Enabled : PanMode.Disabled;
            this._panImagesSubject$ = new Subject();
            this._panImages$ = this._panImagesSubject$.pipe(startWith([]), publishReplay(1), refCount());
            this._subscriptions.push(this._panImages$.subscribe());
        }
        get panImages$() {
            return this._panImages$;
        }
        dispose() {
            this.stop();
            if (this._panImagesSubscription != null) {
                this._panImagesSubscription.unsubscribe();
            }
            this._subscriptions.unsubscribe();
        }
        enable() {
            if (this._mode !== PanMode.Disabled) {
                return;
            }
            this._mode = PanMode.Enabled;
            this.start();
        }
        disable() {
            if (this._mode === PanMode.Disabled) {
                return;
            }
            this.stop();
            this._mode = PanMode.Disabled;
        }
        start() {
            if (this._mode !== PanMode.Enabled) {
                return;
            }
            const panImages$ = this._stateService.currentImage$.pipe(switchMap((current) => {
                if (!current.merged || isSpherical(current.cameraType)) {
                    return of([]);
                }
                const current$ = of(current);
                const bounds = this._graphCalculator.boundingBoxCorners(current.lngLat, 20);
                const adjacent$ = this._graphService
                    .cacheBoundingBox$(bounds[0], bounds[1]).pipe(catchError((error) => {
                    console.error(`Failed to cache periphery bounding box (${current.id})`, error);
                    return empty();
                }), map((images) => {
                    if (isSpherical(current.cameraType)) {
                        return [];
                    }
                    const potential = [];
                    for (const image of images) {
                        if (image.id === current.id) {
                            continue;
                        }
                        if (image.mergeId !== current.mergeId) {
                            continue;
                        }
                        if (isSpherical(image.cameraType)) {
                            continue;
                        }
                        if (this._distance(image, current) > 4) {
                            continue;
                        }
                        potential.push(image);
                    }
                    return potential;
                }));
                return combineLatest(current$, adjacent$).pipe(withLatestFrom(this._stateService.reference$), map(([[cn, adjacent], reference]) => {
                    const currentDirection = this._spatial.viewingDirection(cn.rotation);
                    const currentTranslation = computeTranslation({ lat: cn.lngLat.lat, lng: cn.lngLat.lng, alt: cn.computedAltitude }, cn.rotation, reference);
                    const currentTransform = this._createTransform(cn, currentTranslation);
                    const currentAzimuthal = this._spatial.wrap(this._spatial.azimuthal(currentDirection.toArray(), currentTransform.upVector().toArray()), 0, 2 * Math.PI);
                    const currentProjectedPoints = this._computeProjectedPoints(currentTransform);
                    const currentHFov = this._computeHorizontalFov(currentProjectedPoints) / 180 * Math.PI;
                    const preferredOverlap = Math.PI / 8;
                    let left = undefined;
                    let right = undefined;
                    for (const a of adjacent) {
                        const translation = computeTranslation({ lat: a.lngLat.lat, lng: a.lngLat.lng, alt: a.computedAltitude }, a.rotation, reference);
                        const transform = this._createTransform(a, translation);
                        const projectedPoints = this._computeProjectedPoints(transform);
                        const hFov = this._computeHorizontalFov(projectedPoints) / 180 * Math.PI;
                        const direction = this._spatial.viewingDirection(a.rotation);
                        const azimuthal = this._spatial.wrap(this._spatial.azimuthal(direction.toArray(), transform.upVector().toArray()), 0, 2 * Math.PI);
                        const directionChange = this._spatial.angleBetweenVector2(currentDirection.x, currentDirection.y, direction.x, direction.y);
                        let overlap = Number.NEGATIVE_INFINITY;
                        if (directionChange > 0) {
                            if (currentAzimuthal > azimuthal) {
                                overlap = currentAzimuthal - 2 * Math.PI + currentHFov / 2 - (azimuthal - hFov / 2);
                            }
                            else {
                                overlap = currentAzimuthal + currentHFov / 2 - (azimuthal - hFov / 2);
                            }
                        }
                        else {
                            if (currentAzimuthal < azimuthal) {
                                overlap = azimuthal + hFov / 2 - (currentAzimuthal + 2 * Math.PI - currentHFov / 2);
                            }
                            else {
                                overlap = azimuthal + hFov / 2 - (currentAzimuthal - currentHFov / 2);
                            }
                        }
                        const nonOverlap = Math.abs(hFov - overlap);
                        const distanceCost = this._distance(a, cn);
                        const timeCost = Math.min(this._timeDifference(a, cn), 4);
                        const overlapCost = 20 * Math.abs(overlap - preferredOverlap);
                        const fovCost = Math.min(5, 1 / Math.min(hFov / currentHFov, 1));
                        const nonOverlapCost = overlap > 0 ? -2 * nonOverlap : 0;
                        const cost = distanceCost + timeCost + overlapCost + fovCost + nonOverlapCost;
                        if (overlap > 0 &&
                            overlap < 0.5 * currentHFov &&
                            overlap < 0.5 * hFov &&
                            nonOverlap > 0.5 * currentHFov) {
                            if (directionChange > 0) {
                                if (!left) {
                                    left = [cost, a, transform, hFov];
                                }
                                else {
                                    if (cost < left[0]) {
                                        left = [cost, a, transform, hFov];
                                    }
                                }
                            }
                            else {
                                if (!right) {
                                    right = [cost, a, transform, hFov];
                                }
                                else {
                                    if (cost < right[0]) {
                                        right = [cost, a, transform, hFov];
                                    }
                                }
                            }
                        }
                    }
                    const panImagess = [];
                    if (!!left) {
                        panImagess.push([left[1], left[2], left[3]]);
                    }
                    if (!!right) {
                        panImagess.push([right[1], right[2], right[3]]);
                    }
                    return panImagess;
                }), startWith([]));
            }));
            this._panImagesSubscription = this._stateService.currentState$.pipe(map((frame) => {
                return frame.state.imagesAhead > 0;
            }), distinctUntilChanged(), switchMap((traversing) => {
                return traversing ? of([]) : panImages$;
            }))
                .subscribe((panImages) => {
                this._panImagesSubject$.next(panImages);
            });
            this._mode = PanMode.Started;
        }
        stop() {
            if (this._mode !== PanMode.Started) {
                return;
            }
            this._panImagesSubscription.unsubscribe();
            this._panImagesSubject$.next([]);
            this._mode = PanMode.Enabled;
        }
        _distance(image, reference) {
            const [x, y, z] = geodeticToEnu(image.lngLat.lng, image.lngLat.lat, image.computedAltitude, reference.lngLat.lng, reference.lngLat.lat, reference.computedAltitude);
            return Math.sqrt(x * x + y * y + z * z);
        }
        _timeDifference(image, reference) {
            const milliSecond = (1000 * 60 * 60 * 24 * 30);
            return Math.abs(image.capturedAt - reference.capturedAt) / milliSecond;
        }
        _createTransform(image, translation) {
            return new Transform(image.exifOrientation, image.width, image.height, image.scale, image.rotation, translation, image.assetsCached ? image.image : undefined, undefined, image.cameraParameters, image.cameraType);
        }
        _computeProjectedPoints(transform) {
            const vertices = [[1, 0]];
            const directions = [[0, 0.5]];
            const pointsPerLine = 20;
            return computeProjectedPoints(transform, vertices, directions, pointsPerLine, this._viewportCoords);
        }
        _computeHorizontalFov(projectedPoints) {
            const fovs = projectedPoints
                .map((projectedPoint) => {
                return this._coordToFov(projectedPoint[0]);
            });
            const fov = Math.min(...fovs);
            return fov;
        }
        _coordToFov(x) {
            return 2 * Math.atan(x) * 180 / Math.PI;
        }
    }

    /**
     * @class API
     *
     * @classdesc Provides methods for access to the API.
     */
    class APIWrapper {
        constructor(_data) {
            this._data = _data;
        }
        get data() {
            return this._data;
        }
        getCoreImages$(cellId) {
            return this._wrap$(this._data.getCoreImages(cellId));
        }
        getImages$(imageIds) {
            return this._wrap$(this._data.getImages(imageIds));
        }
        getImageTiles$(tiles) {
            return this._wrap$(this._data.getImageTiles(tiles));
        }
        getSequence$(sequenceId) {
            return this._wrap$(this._data.getSequence(sequenceId));
        }
        getSpatialImages$(imageIds) {
            return this._wrap$(this._data.getSpatialImages(imageIds));
        }
        setAccessToken(accessToken) {
            this._data.setAccessToken(accessToken);
        }
        _wrap$(promise) {
            return Observable.create((subscriber) => {
                promise.then((value) => {
                    subscriber.next(value);
                    subscriber.complete();
                }, (error) => {
                    subscriber.error(error);
                });
            });
        }
    }

    /**
     * @class GraphService
     *
     * @classdesc Represents a service for graph operations.
     */
    class GraphService {
        /**
         * Create a new graph service instance.
         *
         * @param {Graph} graph - Graph instance to be operated on.
         */
        constructor(graph) {
            this._dataAdded$ = new Subject();
            this._subscriptions = new SubscriptionHolder();
            this._onDataAdded = (event) => {
                this._graph$
                    .pipe(first(), mergeMap(graph => {
                    return graph.updateCells$(event.cellIds).pipe(tap(() => { graph.resetSpatialEdges(); }));
                }))
                    .subscribe(cellId => { this._dataAdded$.next(cellId); });
            };
            const subs = this._subscriptions;
            this._graph$ = concat(of(graph), graph.changed$).pipe(publishReplay(1), refCount());
            subs.push(this._graph$.subscribe(() => { }));
            this._graphMode = GraphMode.Spatial;
            this._graphModeSubject$ = new Subject();
            this._graphMode$ = this._graphModeSubject$.pipe(startWith(this._graphMode), publishReplay(1), refCount());
            subs.push(this._graphMode$.subscribe(() => { }));
            this._firstGraphSubjects$ = [];
            this._initializeCacheSubscriptions = [];
            this._sequenceSubscriptions = [];
            this._spatialSubscriptions = [];
            graph.api.data.on("datacreate", this._onDataAdded);
        }
        /**
         * Get dataAdded$.
         *
         * @returns {Observable<string>} Observable emitting
         * a cell id every time data has been added to a cell.
         */
        get dataAdded$() {
            return this._dataAdded$;
        }
        /**
         * Get filter observable.
         *
         * @desciption Emits the filter every time it has changed.
         *
         * @returns {Observable<FilterFunction>} Observable
         * emitting the filter function every time it is set.
         */
        get filter$() {
            return this._graph$.pipe(first(), mergeMap((graph) => {
                return graph.filter$;
            }));
        }
        /**
         * Get graph mode observable.
         *
         * @description Emits the current graph mode.
         *
         * @returns {Observable<GraphMode>} Observable
         * emitting the current graph mode when it changes.
         */
        get graphMode$() {
            return this._graphMode$;
        }
        /**
         * Cache full images in a bounding box.
         *
         * @description When called, the full properties of
         * the image are retrieved. The image cache is not initialized
         * for any new images retrieved and the image assets are not
         * retrieved, {@link cacheImage$} needs to be called for caching
         * assets.
         *
         * @param {LngLat} sw - South west corner of bounding box.
         * @param {LngLat} ne - North east corner of bounding box.
         * @return {Observable<Array<Image>>} Observable emitting a single item,
         * the images of the bounding box, when they have all been retrieved.
         * @throws {Error} Propagates any IO image caching errors to the caller.
         */
        cacheBoundingBox$(sw, ne) {
            return this._graph$.pipe(first(), mergeMap((graph) => {
                return graph.cacheBoundingBox$(sw, ne);
            }));
        }
        /**
         * Cache full images in a cell.
         *
         * @description When called, the full properties of
         * the image are retrieved. The image cache is not initialized
         * for any new images retrieved and the image assets are not
         * retrieved, {@link cacheImage$} needs to be called for caching
         * assets.
         *
         * @param {string} cellId - Id of the cell.
         * @return {Observable<Array<Image>>} Observable emitting a single item,
         * the images of the cell, when they have all been retrieved.
         * @throws {Error} Propagates any IO image caching errors to the caller.
         */
        cacheCell$(cellId) {
            return this._graph$.pipe(first(), mergeMap((graph) => {
                return graph.cacheCell$(cellId);
            }));
        }
        /**
         * Cache a image in the graph and retrieve it.
         *
         * @description When called, the full properties of
         * the image are retrieved and the image cache is initialized.
         * After that the image assets are cached and the image
         * is emitted to the observable when.
         * In parallel to caching the image assets, the sequence and
         * spatial edges of the image are cached. For this, the sequence
         * of the image and the required tiles and spatial images are
         * retrieved. The sequence and spatial edges may be set before
         * or after the image is returned.
         *
         * @param {string} id - Id of the image to cache.
         * @return {Observable<Image>} Observable emitting a single item,
         * the image, when it has been retrieved and its assets are cached.
         * @throws {Error} Propagates any IO image caching errors to the caller.
         */
        cacheImage$(id) {
            const firstGraphSubject$ = new Subject();
            this._firstGraphSubjects$.push(firstGraphSubject$);
            const firstGraph$ = firstGraphSubject$.pipe(publishReplay(1), refCount());
            const image$ = firstGraph$.pipe(map((graph) => {
                return graph.getNode(id);
            }), mergeMap((image) => {
                return image.assetsCached ?
                    of(image) :
                    image.cacheAssets$();
            }), publishReplay(1), refCount());
            image$.subscribe(undefined, (error) => {
                console.error(`Failed to cache image (${id}).`, error);
            });
            let initializeCacheSubscription;
            initializeCacheSubscription = this._graph$.pipe(first(), mergeMap((graph) => {
                if (graph.isCachingFull(id) || !graph.hasNode(id)) {
                    return graph.cacheFull$(id);
                }
                if (graph.isCachingFill(id) || !graph.getNode(id).complete) {
                    return graph.cacheFill$(id);
                }
                return of(graph);
            }), tap((graph) => {
                if (!graph.hasNode(id)) {
                    throw new GraphMapillaryError(`Failed to cache image (${id})`);
                }
                if (!graph.hasInitializedCache(id)) {
                    graph.initializeCache(id);
                }
            }), finalize(() => {
                if (initializeCacheSubscription == null) {
                    return;
                }
                this._removeFromArray(initializeCacheSubscription, this._initializeCacheSubscriptions);
                this._removeFromArray(firstGraphSubject$, this._firstGraphSubjects$);
            }))
                .subscribe((graph) => {
                firstGraphSubject$.next(graph);
                firstGraphSubject$.complete();
            }, (error) => {
                firstGraphSubject$.error(error);
            });
            if (!initializeCacheSubscription.closed) {
                this._initializeCacheSubscriptions.push(initializeCacheSubscription);
            }
            const graphSequence$ = firstGraph$.pipe(catchError(() => {
                return empty();
            }), mergeMap((graph) => {
                if (graph.isCachingNodeSequence(id) || !graph.hasNodeSequence(id)) {
                    return graph.cacheNodeSequence$(id);
                }
                return of(graph);
            }), publishReplay(1), refCount());
            let sequenceSubscription;
            sequenceSubscription = graphSequence$.pipe(tap((graph) => {
                if (!graph.getNode(id).sequenceEdges.cached) {
                    graph.cacheSequenceEdges(id);
                }
            }), finalize(() => {
                if (sequenceSubscription == null) {
                    return;
                }
                this._removeFromArray(sequenceSubscription, this._sequenceSubscriptions);
            }))
                .subscribe(() => { return; }, (error) => {
                console.error(`Failed to cache sequence edges (${id}).`, error);
            });
            if (!sequenceSubscription.closed) {
                this._sequenceSubscriptions.push(sequenceSubscription);
            }
            if (this._graphMode === GraphMode.Spatial) {
                let spatialSubscription;
                spatialSubscription = firstGraph$.pipe(catchError(() => {
                    return empty();
                }), expand((graph) => {
                    if (graph.hasTiles(id)) {
                        return empty();
                    }
                    return from(graph.cacheTiles$(id)).pipe(mergeMap((graph$) => {
                        return graph$.pipe(mergeMap((g) => {
                            if (g.isCachingTiles(id)) {
                                return empty();
                            }
                            return of(g);
                        }), catchError((error) => {
                            console.error(`Failed to cache tile data (${id}).`, error);
                            return empty();
                        }));
                    }));
                }), takeLast(1), mergeMap((graph) => {
                    if (graph.hasSpatialArea(id)) {
                        return of(graph);
                    }
                    return from(graph.cacheSpatialArea$(id)).pipe(mergeMap((graph$) => {
                        return graph$.pipe(catchError((error) => {
                            console.error(`Failed to cache spatial images (${id}).`, error);
                            return empty();
                        }));
                    }));
                }), takeLast(1), mergeMap((graph) => {
                    return graph.hasNodeSequence(id) ?
                        of(graph) :
                        graph.cacheNodeSequence$(id);
                }), tap((graph) => {
                    if (!graph.getNode(id).spatialEdges.cached) {
                        graph.cacheSpatialEdges(id);
                    }
                }), finalize(() => {
                    if (spatialSubscription == null) {
                        return;
                    }
                    this._removeFromArray(spatialSubscription, this._spatialSubscriptions);
                }))
                    .subscribe(() => { return; }, (error) => {
                    const message = `Failed to cache spatial edges (${id}).`;
                    console.error(message, error);
                });
                if (!spatialSubscription.closed) {
                    this._spatialSubscriptions.push(spatialSubscription);
                }
            }
            return image$.pipe(first((image) => {
                return image.assetsCached;
            }));
        }
        /**
         * Cache a sequence in the graph and retrieve it.
         *
         * @param {string} sequenceId - Sequence id.
         * @returns {Observable<Sequence>} Observable emitting a single item,
         * the sequence, when it has been retrieved and its assets are cached.
         * @throws {Error} Propagates any IO image caching errors to the caller.
         */
        cacheSequence$(sequenceId) {
            return this._graph$.pipe(first(), mergeMap((graph) => {
                if (graph.isCachingSequence(sequenceId) || !graph.hasSequence(sequenceId)) {
                    return graph.cacheSequence$(sequenceId);
                }
                return of(graph);
            }), map((graph) => {
                return graph.getSequence(sequenceId);
            }));
        }
        /**
         * Cache a sequence and its images in the graph and retrieve the sequence.
         *
         * @description Caches a sequence and its assets are cached and
         * retrieves all images belonging to the sequence. The image assets
         * or edges will not be cached.
         *
         * @param {string} sequenceId - Sequence id.
         * @param {string} referenceImageId - Id of image to use as reference
         * for optimized caching.
         * @returns {Observable<Sequence>} Observable emitting a single item,
         * the sequence, when it has been retrieved, its assets are cached and
         * all images belonging to the sequence has been retrieved.
         * @throws {Error} Propagates any IO image caching errors to the caller.
         */
        cacheSequenceImages$(sequenceId, referenceImageId) {
            return this._graph$.pipe(first(), mergeMap((graph) => {
                if (graph.isCachingSequence(sequenceId) || !graph.hasSequence(sequenceId)) {
                    return graph.cacheSequence$(sequenceId);
                }
                return of(graph);
            }), mergeMap((graph) => {
                if (graph.isCachingSequenceNodes(sequenceId) || !graph.hasSequenceNodes(sequenceId)) {
                    return graph.cacheSequenceNodes$(sequenceId, referenceImageId);
                }
                return of(graph);
            }), map((graph) => {
                return graph.getSequence(sequenceId);
            }));
        }
        /**
         * Dispose the graph service and its children.
         */
        dispose() {
            this._graph$
                .pipe(first())
                .subscribe((graph) => { graph.unsubscribe(); });
            this._subscriptions.unsubscribe();
        }
        /**
         * Set a spatial edge filter on the graph.
         *
         * @description Resets the spatial edges of all cached images.
         *
         * @param {FilterExpression} filter - Filter expression to be applied.
         * @return {Observable<Graph>} Observable emitting a single item,
         * the graph, when the spatial edges have been reset.
         */
        setFilter$(filter) {
            this._resetSubscriptions(this._spatialSubscriptions);
            return this._graph$.pipe(first(), tap((graph) => {
                graph.resetSpatialEdges();
                graph.setFilter(filter);
            }), map(() => {
                return undefined;
            }));
        }
        /**
         * Set the graph mode.
         *
         * @description If graph mode is set to spatial, caching
         * is performed with emphasis on spatial edges. If graph
         * mode is set to sequence no tile data is requested and
         * no spatial edges are computed.
         *
         * When setting graph mode to sequence all spatial
         * subscriptions are aborted.
         *
         * @param {GraphMode} mode - Graph mode to set.
         */
        setGraphMode(mode) {
            if (this._graphMode === mode) {
                return;
            }
            if (mode === GraphMode.Sequence) {
                this._resetSubscriptions(this._spatialSubscriptions);
            }
            this._graphMode = mode;
            this._graphModeSubject$.next(this._graphMode);
        }
        /**
         * Reset the graph.
         *
         * @description Resets the graph but keeps the images of the
         * supplied ids.
         *
         * @param {Array<string>} keepIds - Ids of images to keep in graph.
         * @return {Observable<Image>} Observable emitting a single item,
         * the graph, when it has been reset.
         */
        reset$(keepIds) {
            this._abortSubjects(this._firstGraphSubjects$);
            this._resetSubscriptions(this._initializeCacheSubscriptions);
            this._resetSubscriptions(this._sequenceSubscriptions);
            this._resetSubscriptions(this._spatialSubscriptions);
            return this._graph$.pipe(first(), tap((graph) => {
                graph.reset(keepIds);
            }), map(() => {
                return undefined;
            }));
        }
        /**
         * Uncache the graph.
         *
         * @description Uncaches the graph by removing tiles, images and
         * sequences. Keeps the images of the supplied ids and the tiles
         * related to those images.
         *
         * @param {Array<string>} keepIds - Ids of images to keep in graph.
         * @param {Array<string>} keepCellIds - Ids of cells to keep in graph.
         * @param {string} keepSequenceId - Optional id of sequence
         * for which the belonging images should not be disposed or
         * removed from the graph. These images may still be uncached if
         * not specified in keep ids param.
         * @return {Observable<Graph>} Observable emitting a single item,
         * the graph, when the graph has been uncached.
         */
        uncache$(keepIds, keepCellIds, keepSequenceId) {
            return this._graph$.pipe(first(), tap((graph) => {
                graph.uncache(keepIds, keepCellIds, keepSequenceId);
            }), map(() => {
                return undefined;
            }));
        }
        _abortSubjects(subjects) {
            for (const subject of subjects.slice()) {
                this._removeFromArray(subject, subjects);
                subject.error(new Error("Cache image request was aborted."));
            }
        }
        _removeFromArray(object, objects) {
            const index = objects.indexOf(object);
            if (index !== -1) {
                objects.splice(index, 1);
            }
        }
        _resetSubscriptions(subscriptions) {
            for (const subscription of subscriptions.slice()) {
                this._removeFromArray(subscription, subscriptions);
                if (!subscription.closed) {
                    subscription.unsubscribe();
                }
            }
        }
    }

    class FrameGenerator {
        constructor(root) {
            if (root.requestAnimationFrame) {
                this._cancelAnimationFrame = root.cancelAnimationFrame.bind(root);
                this._requestAnimationFrame = root.requestAnimationFrame.bind(root);
            }
            else if (root.mozRequestAnimationFrame) {
                this._cancelAnimationFrame = root.mozCancelAnimationFrame.bind(root);
                this._requestAnimationFrame = root.mozRequestAnimationFrame.bind(root);
            }
            else if (root.webkitRequestAnimationFrame) {
                this._cancelAnimationFrame = root.webkitCancelAnimationFrame.bind(root);
                this._requestAnimationFrame = root.webkitRequestAnimationFrame.bind(root);
            }
            else if (root.msRequestAnimationFrame) {
                this._cancelAnimationFrame = root.msCancelAnimationFrame.bind(root);
                this._requestAnimationFrame = root.msRequestAnimationFrame.bind(root);
            }
            else if (root.oRequestAnimationFrame) {
                this._cancelAnimationFrame = root.oCancelAnimationFrame.bind(root);
                this._requestAnimationFrame = root.oRequestAnimationFrame.bind(root);
            }
            else {
                this._cancelAnimationFrame = root.clearTimeout.bind(root);
                this._requestAnimationFrame = (cb) => { return root.setTimeout(cb, 1000 / 60); };
            }
        }
        get cancelAnimationFrame() {
            return this._cancelAnimationFrame;
        }
        get requestAnimationFrame() {
            return this._requestAnimationFrame;
        }
    }

    class CustomState extends StateBase {
        constructor(state) {
            super(state);
        }
        setViewMatrix(viewMatrix) {
            const viewMatrixInverse = new Matrix4()
                .fromArray(viewMatrix)
                .invert();
            const me = viewMatrixInverse.elements;
            const eye = new Vector3(me[12], me[13], me[14]);
            const forward = new Vector3(-me[8], -me[9], -me[10]);
            const up = new Vector3(me[4], me[5], me[6]);
            const camera = this._camera;
            camera.position.copy(eye);
            camera.lookat.copy(eye
                .clone()
                .add(forward));
            camera.up.copy(up);
            const focal = 0.5 / Math.tan(Math.PI / 3);
            camera.focal = focal;
        }
    }

    class EarthState extends StateBase {
        constructor(state) {
            super(state);
            const eye = this._camera.position.clone();
            const forward = this._camera.lookat
                .clone()
                .sub(eye)
                .normalize();
            const xy = Math.sqrt(forward.x * forward.x + forward.y * forward.y);
            const angle = Math.atan2(forward.z, xy);
            const lookat = new Vector3();
            if (angle > -Math.PI / 45) {
                lookat.copy(eye);
                eye.add(new Vector3(forward.x, forward.y, 0)
                    .multiplyScalar(-50));
                eye.z = 30;
            }
            else {
                // Target a point on invented ground and keep forward direction
                const l0 = eye.clone();
                const n = new Vector3(0, 0, 1);
                const p0 = new Vector3(0, 0, -2);
                const d = new Vector3().subVectors(p0, l0).dot(n) / forward.dot(n);
                const maxDistance = 10000;
                const intersection = l0
                    .clone()
                    .add(forward.
                    clone()
                    .multiplyScalar(Math.min(maxDistance, d)));
                lookat.copy(intersection);
                const t = eye
                    .clone()
                    .sub(intersection)
                    .normalize();
                eye.copy(intersection.add(t.multiplyScalar(Math.max(50, t.length()))));
            }
            this._camera.position.copy(eye);
            this._camera.lookat.copy(lookat);
            this._camera.up.set(0, 0, 1);
        }
        dolly(delta) {
            const camera = this._camera;
            const offset = camera.position
                .clone()
                .sub(camera.lookat);
            const length = offset.length();
            const scaled = length * Math.pow(2, -delta);
            const clipped = Math.max(1, Math.min(scaled, 4000));
            offset.normalize();
            offset.multiplyScalar(clipped);
            camera.position
                .copy(camera.lookat)
                .add(offset);
        }
        orbit(rotation) {
            const camera = this._camera;
            const q = new Quaternion()
                .setFromUnitVectors(camera.up, new Vector3(0, 0, 1));
            const qInverse = q
                .clone()
                .invert();
            const offset = camera.position
                .clone()
                .sub(camera.lookat);
            offset.applyQuaternion(q);
            const length = offset.length();
            let phi = Math.atan2(offset.y, offset.x);
            phi += rotation.phi;
            let theta = Math.atan2(Math.sqrt(offset.x * offset.x + offset.y * offset.y), offset.z);
            theta += rotation.theta;
            const threshold = Math.PI / 36;
            theta = Math.max(threshold, Math.min(Math.PI / 2 - threshold, theta));
            offset.x = Math.sin(theta) * Math.cos(phi);
            offset.y = Math.sin(theta) * Math.sin(phi);
            offset.z = Math.cos(theta);
            offset.applyQuaternion(qInverse);
            camera.position
                .copy(camera.lookat)
                .add(offset.multiplyScalar(length));
        }
        truck(direction) {
            const camera = this._camera;
            camera.position
                .add(new Vector3().fromArray(direction));
            camera.lookat
                .add(new Vector3().fromArray(direction));
        }
        update() { }
    }

    class InteractiveWaitingState extends InteractiveStateBase {
        constructor(state) {
            super(state);
            this._adjustCameras();
            this._motionless = this._motionlessTransition();
        }
        prepend(images) {
            super.prepend(images);
            this._motionless = this._motionlessTransition();
        }
        set(images) {
            super.set(images);
            this._motionless = this._motionlessTransition();
        }
        move(delta) {
            this._alpha = Math.max(0, Math.min(1, this._alpha + delta));
        }
        moveTo(position) {
            this._alpha = Math.max(0, Math.min(1, position));
        }
        update(fps) {
            this._updateRotation();
            if (!this._rotationDelta.isZero) {
                this._applyRotation(this._rotationDelta, this._previousCamera);
                this._applyRotation(this._rotationDelta, this._currentCamera);
            }
            this._updateRotationBasic();
            if (this._basicRotation[0] !== 0 || this._basicRotation[1] !== 0) {
                this._applyRotationBasic(this._basicRotation);
            }
            let animationSpeed = this._animationSpeed * (60 / fps);
            this._updateZoom(animationSpeed);
            this._updateLookat(animationSpeed);
            this._camera.lerpCameras(this._previousCamera, this._currentCamera, this.alpha);
        }
        _getAlpha() {
            return this._motionless ? Math.round(this._alpha) : this._alpha;
        }
        _setCurrentCamera() {
            super._setCurrentCamera();
            this._adjustCameras();
        }
        _adjustCameras() {
            if (this._previousImage == null) {
                return;
            }
            if (isSpherical(this._currentImage.cameraType)) {
                let lookat = this._camera.lookat.clone().sub(this._camera.position);
                this._currentCamera.lookat.copy(lookat.clone().add(this._currentCamera.position));
            }
            if (isSpherical(this._previousImage.cameraType)) {
                let lookat = this._currentCamera.lookat.clone().sub(this._currentCamera.position);
                this._previousCamera.lookat.copy(lookat.clone().add(this._previousCamera.position));
            }
        }
    }

    class WaitingState extends StateBase {
        constructor(state) {
            super(state);
            this._zoom = 0;
            this._adjustCameras();
            this._motionless = this._motionlessTransition();
        }
        prepend(images) {
            super.prepend(images);
            this._motionless = this._motionlessTransition();
        }
        set(images) {
            super.set(images);
            this._motionless = this._motionlessTransition();
        }
        move(delta) {
            this._alpha = Math.max(0, Math.min(1, this._alpha + delta));
        }
        moveTo(position) {
            this._alpha = Math.max(0, Math.min(1, position));
        }
        update(fps) {
            this._camera.lerpCameras(this._previousCamera, this._currentCamera, this.alpha);
        }
        _getAlpha() {
            return this._motionless ? Math.round(this._alpha) : this._alpha;
        }
        _setCurrentCamera() {
            super._setCurrentCamera();
            this._adjustCameras();
        }
        _adjustCameras() {
            if (this._previousImage == null) {
                return;
            }
            if (isSpherical(this._currentImage.cameraType)) {
                let lookat = this._camera.lookat.clone().sub(this._camera.position);
                this._currentCamera.lookat.copy(lookat.clone().add(this._currentCamera.position));
            }
            if (isSpherical(this._previousImage.cameraType)) {
                let lookat = this._currentCamera.lookat.clone().sub(this._currentCamera.position);
                this._previousCamera.lookat.copy(lookat.clone().add(this._previousCamera.position));
            }
        }
    }

    class StateTransitionMatrix {
        constructor() {
            const custom = State[State.Custom];
            const earth = State[State.Earth];
            const traverse = State[State.Traversing];
            const wait = State[State.Waiting];
            const waitInteractively = State[State.WaitingInteractively];
            this._creators = new Map();
            const creator = this._creators;
            creator.set(custom, CustomState);
            creator.set(earth, EarthState);
            creator.set(traverse, TraversingState);
            creator.set(wait, WaitingState);
            creator.set(waitInteractively, InteractiveWaitingState);
            this._transitions = new Map();
            const transitions = this._transitions;
            transitions.set(custom, [earth, traverse]);
            transitions.set(earth, [custom, traverse]);
            transitions.set(traverse, [custom, earth, wait, waitInteractively]);
            transitions.set(wait, [traverse, waitInteractively]);
            transitions.set(waitInteractively, [traverse, wait]);
        }
        getState(state) {
            if (state instanceof CustomState) {
                return State.Custom;
            }
            else if (state instanceof EarthState) {
                return State.Earth;
            }
            else if (state instanceof TraversingState) {
                return State.Traversing;
            }
            else if (state instanceof WaitingState) {
                return State.Waiting;
            }
            else if (state instanceof InteractiveWaitingState) {
                return State.WaitingInteractively;
            }
            throw new Error("Invalid state instance");
        }
        generate(state, options) {
            const concreteState = this._creators.get(State[state]);
            return new concreteState(options);
        }
        transition(state, to) {
            if (!this.validate(state, to)) {
                throw new Error("Invalid transition");
            }
            return this.generate(to, state);
        }
        validate(state, to) {
            const source = State[this.getState(state)];
            const target = State[to];
            const transitions = this._transitions;
            return transitions.has(source) &&
                transitions.get(source).includes(target);
        }
    }

    class StateContext {
        constructor(state, transitionMode) {
            this._transitions = new StateTransitionMatrix();
            this._state = this._transitions.generate(state, {
                alpha: 1,
                camera: new Camera(),
                currentIndex: -1,
                reference: { alt: 0, lat: 0, lng: 0 },
                trajectory: [],
                transitionMode: transitionMode == null ? exports.TransitionMode.Default : transitionMode,
                zoom: 0,
            });
        }
        get state() {
            return this._transitions.getState(this._state);
        }
        get reference() {
            return this._state.reference;
        }
        get alpha() {
            return this._state.alpha;
        }
        get camera() {
            return this._state.camera;
        }
        get zoom() {
            return this._state.zoom;
        }
        get currentImage() {
            return this._state.currentImage;
        }
        get previousImage() {
            return this._state.previousImage;
        }
        get currentCamera() {
            return this._state.currentCamera;
        }
        get currentTransform() {
            return this._state.currentTransform;
        }
        get previousTransform() {
            return this._state.previousTransform;
        }
        get trajectory() {
            return this._state.trajectory;
        }
        get currentIndex() {
            return this._state.currentIndex;
        }
        get lastImage() {
            return this._state.trajectory[this._state.trajectory.length - 1];
        }
        get imagesAhead() {
            return this._state.trajectory.length - 1 - this._state.currentIndex;
        }
        get motionless() {
            return this._state.motionless;
        }
        custom() {
            this._transition(State.Custom);
        }
        earth() {
            this._transition(State.Earth);
        }
        traverse() {
            this._transition(State.Traversing);
        }
        wait() {
            this._transition(State.Waiting);
        }
        waitInteractively() {
            this._transition(State.WaitingInteractively);
        }
        getCenter() {
            return this._state.getCenter();
        }
        setCenter(center) {
            this._state.setCenter(center);
        }
        setZoom(zoom) {
            this._state.setZoom(zoom);
        }
        update(fps) {
            this._state.update(fps);
        }
        append(images) {
            this._state.append(images);
        }
        prepend(images) {
            this._state.prepend(images);
        }
        remove(n) {
            this._state.remove(n);
        }
        clear() {
            this._state.clear();
        }
        clearPrior() {
            this._state.clearPrior();
        }
        cut() {
            this._state.cut();
        }
        set(images) {
            this._state.set(images);
        }
        setViewMatrix(matrix) {
            this._state.setViewMatrix(matrix);
        }
        rotate(delta) {
            this._state.rotate(delta);
        }
        rotateUnbounded(delta) {
            this._state.rotateUnbounded(delta);
        }
        rotateWithoutInertia(delta) {
            this._state.rotateWithoutInertia(delta);
        }
        rotateBasic(basicRotation) {
            this._state.rotateBasic(basicRotation);
        }
        rotateBasicUnbounded(basicRotation) {
            this._state.rotateBasicUnbounded(basicRotation);
        }
        rotateBasicWithoutInertia(basicRotation) {
            this._state.rotateBasicWithoutInertia(basicRotation);
        }
        rotateToBasic(basic) {
            this._state.rotateToBasic(basic);
        }
        move(delta) {
            this._state.move(delta);
        }
        moveTo(delta) {
            this._state.moveTo(delta);
        }
        zoomIn(delta, reference) {
            this._state.zoomIn(delta, reference);
        }
        setSpeed(speed) {
            this._state.setSpeed(speed);
        }
        setTransitionMode(mode) {
            this._state.setTransitionMode(mode);
        }
        dolly(delta) {
            this._state.dolly(delta);
        }
        orbit(rotation) {
            this._state.orbit(rotation);
        }
        truck(direction) {
            this._state.truck(direction);
        }
        _transition(to) {
            if (!this._transitions.validate(this._state, to)) {
                const from = this._transitions.getState(this._state);
                console.warn(`Transition not valid (${State[from]} - ${State[to]})`);
                return;
            }
            const state = this._transitions.transition(this._state, to);
            this._state = state;
        }
    }

    class StateService {
        constructor(initialState, transitionMode) {
            this._appendImage$ = new Subject();
            this._subscriptions = new SubscriptionHolder();
            const subs = this._subscriptions;
            this._start$ = new Subject();
            this._frame$ = new Subject();
            this._fpsSampleRate = 30;
            this._contextOperation$ = new BehaviorSubject((context) => {
                return context;
            });
            this._context$ = this._contextOperation$.pipe(scan((context, operation) => {
                return operation(context);
            }, new StateContext(initialState, transitionMode)), publishReplay(1), refCount());
            this._state$ = this._context$.pipe(map((context) => {
                return context.state;
            }), distinctUntilChanged(), publishReplay(1), refCount());
            this._fps$ = this._start$.pipe(switchMap(() => {
                return this._frame$.pipe(bufferCount(1, this._fpsSampleRate), map(() => {
                    return new Date().getTime();
                }), pairwise(), map((times) => {
                    return Math.max(20, 1000 * this._fpsSampleRate / (times[1] - times[0]));
                }), startWith(60));
            }), share());
            this._currentState$ = this._frame$.pipe(withLatestFrom(this._fps$, this._context$, (frameId, fps, context) => {
                return [frameId, fps, context];
            }), filter((fc) => {
                return fc[2].currentImage != null;
            }), tap((fc) => {
                fc[2].update(fc[1]);
            }), map((fc) => {
                return { fps: fc[1], id: fc[0], state: fc[2] };
            }), share());
            this._lastState$ = this._currentState$.pipe(publishReplay(1), refCount());
            let imageChanged$ = this._currentState$.pipe(distinctUntilChanged(undefined, (f) => {
                return f.state.currentImage.id;
            }), publishReplay(1), refCount());
            let imageChangedSubject$ = new Subject();
            subs.push(imageChanged$
                .subscribe(imageChangedSubject$));
            this._currentId$ = new BehaviorSubject(null);
            subs.push(imageChangedSubject$.pipe(map((f) => {
                return f.state.currentImage.id;
            }))
                .subscribe(this._currentId$));
            this._currentImage$ = imageChangedSubject$.pipe(map((f) => {
                return f.state.currentImage;
            }), publishReplay(1), refCount());
            this._currentCamera$ = imageChangedSubject$.pipe(map((f) => {
                return f.state.currentCamera;
            }), publishReplay(1), refCount());
            this._currentTransform$ = imageChangedSubject$.pipe(map((f) => {
                return f.state.currentTransform;
            }), publishReplay(1), refCount());
            this._reference$ = imageChangedSubject$.pipe(map((f) => {
                return f.state.reference;
            }), distinctUntilChanged((r1, r2) => {
                return r1.lat === r2.lat && r1.lng === r2.lng;
            }, (reference) => {
                return { lat: reference.lat, lng: reference.lng };
            }), publishReplay(1), refCount());
            this._currentImageExternal$ = imageChanged$.pipe(map((f) => {
                return f.state.currentImage;
            }), publishReplay(1), refCount());
            subs.push(this._appendImage$.pipe(map((image) => {
                return (context) => {
                    context.append([image]);
                    return context;
                };
            }))
                .subscribe(this._contextOperation$));
            this._inMotionOperation$ = new Subject();
            subs.push(imageChanged$.pipe(map(() => {
                return true;
            }))
                .subscribe(this._inMotionOperation$));
            subs.push(this._inMotionOperation$.pipe(distinctUntilChanged(), filter((moving) => {
                return moving;
            }), switchMap(() => {
                return this._currentState$.pipe(filter((frame) => {
                    return frame.state.imagesAhead === 0;
                }), map((frame) => {
                    return [frame.state.camera.clone(), frame.state.zoom];
                }), pairwise(), map((pair) => {
                    let c1 = pair[0][0];
                    let c2 = pair[1][0];
                    let z1 = pair[0][1];
                    let z2 = pair[1][1];
                    return c1.diff(c2) > 1e-5 || Math.abs(z1 - z2) > 1e-5;
                }), first((changed) => {
                    return !changed;
                }));
            }))
                .subscribe(this._inMotionOperation$));
            this._inMotion$ = this._inMotionOperation$.pipe(distinctUntilChanged(), publishReplay(1), refCount());
            this._inTranslationOperation$ = new Subject();
            subs.push(imageChanged$.pipe(map(() => {
                return true;
            }))
                .subscribe(this._inTranslationOperation$));
            subs.push(this._inTranslationOperation$.pipe(distinctUntilChanged(), filter((inTranslation) => {
                return inTranslation;
            }), switchMap(() => {
                return this._currentState$.pipe(filter((frame) => {
                    return frame.state.imagesAhead === 0;
                }), map((frame) => {
                    return frame.state.camera.position.clone();
                }), pairwise(), map((pair) => {
                    return pair[0].distanceToSquared(pair[1]) !== 0;
                }), first((changed) => {
                    return !changed;
                }));
            }))
                .subscribe(this._inTranslationOperation$));
            this._inTranslation$ = this._inTranslationOperation$.pipe(distinctUntilChanged(), publishReplay(1), refCount());
            subs.push(this._state$.subscribe(() => { }));
            subs.push(this._currentImage$.subscribe(() => { }));
            subs.push(this._currentCamera$.subscribe(() => { }));
            subs.push(this._currentTransform$.subscribe(() => { }));
            subs.push(this._reference$.subscribe(() => { }));
            subs.push(this._currentImageExternal$.subscribe(() => { }));
            subs.push(this._lastState$.subscribe(() => { }));
            subs.push(this._inMotion$.subscribe(() => { }));
            subs.push(this._inTranslation$.subscribe(() => { }));
            this._frameId = null;
            this._frameGenerator = new FrameGenerator(window);
        }
        get currentState$() {
            return this._currentState$;
        }
        get currentImage$() {
            return this._currentImage$;
        }
        get currentId$() {
            return this._currentId$;
        }
        get currentImageExternal$() {
            return this._currentImageExternal$;
        }
        get currentCamera$() {
            return this._currentCamera$;
        }
        get currentTransform$() {
            return this._currentTransform$;
        }
        get state$() {
            return this._state$;
        }
        get reference$() {
            return this._reference$;
        }
        get inMotion$() {
            return this._inMotion$;
        }
        get inTranslation$() {
            return this._inTranslation$;
        }
        get appendImage$() {
            return this._appendImage$;
        }
        dispose() {
            this.stop();
            this._subscriptions.unsubscribe();
        }
        custom() {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => {
                context.custom();
            });
        }
        earth() {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.earth(); });
        }
        traverse() {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.traverse(); });
        }
        wait() {
            this._invokeContextOperation((context) => { context.wait(); });
        }
        waitInteractively() {
            this._invokeContextOperation((context) => { context.waitInteractively(); });
        }
        appendImagess(images) {
            this._invokeContextOperation((context) => { context.append(images); });
        }
        prependImages(images) {
            this._invokeContextOperation((context) => { context.prepend(images); });
        }
        removeImages(n) {
            this._invokeContextOperation((context) => { context.remove(n); });
        }
        clearImages() {
            this._invokeContextOperation((context) => { context.clear(); });
        }
        clearPriorImages() {
            this._invokeContextOperation((context) => { context.clearPrior(); });
        }
        cutImages() {
            this._invokeContextOperation((context) => { context.cut(); });
        }
        setImages(images) {
            this._invokeContextOperation((context) => { context.set(images); });
        }
        setViewMatrix(matrix) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.setViewMatrix(matrix); });
        }
        rotate(delta) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotate(delta); });
        }
        rotateUnbounded(delta) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotateUnbounded(delta); });
        }
        rotateWithoutInertia(delta) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotateWithoutInertia(delta); });
        }
        rotateBasic(basicRotation) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotateBasic(basicRotation); });
        }
        rotateBasicUnbounded(basicRotation) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotateBasicUnbounded(basicRotation); });
        }
        rotateBasicWithoutInertia(basicRotation) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotateBasicWithoutInertia(basicRotation); });
        }
        rotateToBasic(basic) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.rotateToBasic(basic); });
        }
        move(delta) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.move(delta); });
        }
        moveTo(position) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.moveTo(position); });
        }
        dolly(delta) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.dolly(delta); });
        }
        orbit(rotation) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.orbit(rotation); });
        }
        truck(direction) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.truck(direction); });
        }
        /**
         * Change zoom level while keeping the reference point position approximately static.
         *
         * @parameter {number} delta - Change in zoom level.
         * @parameter {Array<number>} reference - Reference point in basic coordinates.
         */
        zoomIn(delta, reference) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.zoomIn(delta, reference); });
        }
        getCenter() {
            return this._lastState$.pipe(first(), map((frame) => {
                return frame.state.getCenter();
            }));
        }
        getZoom() {
            return this._lastState$.pipe(first(), map((frame) => {
                return frame.state.zoom;
            }));
        }
        setCenter(center) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.setCenter(center); });
        }
        setSpeed(speed) {
            this._invokeContextOperation((context) => { context.setSpeed(speed); });
        }
        setTransitionMode(mode) {
            this._invokeContextOperation((context) => { context.setTransitionMode(mode); });
        }
        setZoom(zoom) {
            this._inMotionOperation$.next(true);
            this._invokeContextOperation((context) => { context.setZoom(zoom); });
        }
        start() {
            if (this._frameId == null) {
                this._start$.next(null);
                this._frameId = this._frameGenerator.requestAnimationFrame(this._frame.bind(this));
                this._frame$.next(this._frameId);
            }
        }
        stop() {
            if (this._frameId != null) {
                this._frameGenerator.cancelAnimationFrame(this._frameId);
                this._frameId = null;
            }
        }
        _invokeContextOperation(action) {
            this._contextOperation$
                .next((context) => {
                action(context);
                return context;
            });
        }
        _frame() {
            this._frameId = this._frameGenerator.requestAnimationFrame(this._frame.bind(this));
            this._frame$.next(this._frameId);
        }
    }

    function cameraControlsToState(cameraControls) {
        switch (cameraControls) {
            case exports.CameraControls.Custom:
                return State.Custom;
            case exports.CameraControls.Earth:
                return State.Earth;
            case exports.CameraControls.Street:
                return State.Traversing;
            default:
                return null;
        }
    }

    class Navigator {
        constructor(options, api, graphService, loadingService, stateService, cacheService, playService, panService) {
            var _a;
            if (api) {
                this._api = api;
            }
            else if (options.dataProvider) {
                if (options.dataProvider instanceof DataProviderBase) {
                    this._api = new APIWrapper(options.dataProvider);
                }
                else {
                    throw new Error("Incorrect type: 'dataProvider' must extend the DataProviderBase class.");
                }
            }
            else {
                this._api = new APIWrapper(new GraphDataProvider({
                    accessToken: options.accessToken,
                }));
            }
            this._graphService = graphService !== null && graphService !== void 0 ? graphService : new GraphService(new Graph(this.api));
            this._loadingName = "navigator";
            this._loadingService = loadingService !== null && loadingService !== void 0 ? loadingService : new LoadingService();
            const cameraControls = (_a = options.cameraControls) !== null && _a !== void 0 ? _a : exports.CameraControls.Street;
            this._stateService = stateService !== null && stateService !== void 0 ? stateService : new StateService(cameraControlsToState(cameraControls), options.transitionMode);
            this._cacheService = cacheService !== null && cacheService !== void 0 ? cacheService : new CacheService(this._graphService, this._stateService, this._api);
            this._playService = playService !== null && playService !== void 0 ? playService : new PlayService(this._graphService, this._stateService);
            this._panService = panService !== null && panService !== void 0 ? panService : new PanService(this._graphService, this._stateService, options.combinedPanning);
            this._idRequested$ = new BehaviorSubject(null);
            this._movedToId$ = new BehaviorSubject(null);
            this._request$ = null;
            this._requestSubscription = null;
            this._imageRequestSubscription = null;
        }
        get api() {
            return this._api;
        }
        get cacheService() {
            return this._cacheService;
        }
        get graphService() {
            return this._graphService;
        }
        get loadingService() {
            return this._loadingService;
        }
        get movedToId$() {
            return this._movedToId$;
        }
        get panService() {
            return this._panService;
        }
        get playService() {
            return this._playService;
        }
        get stateService() {
            return this._stateService;
        }
        dispose() {
            this._abortRequest("viewer removed");
            this._cacheService.stop();
            this._graphService.dispose();
            this._panService.dispose();
            this._playService.dispose();
            this._stateService.dispose();
        }
        moveTo$(id) {
            this._abortRequest(`to id ${id}`);
            this._loadingService.startLoading(this._loadingName);
            const image$ = this._moveTo$(id);
            return this._makeRequest$(image$);
        }
        moveDir$(direction) {
            this._abortRequest(`in dir ${exports.NavigationDirection[direction]}`);
            this._loadingService.startLoading(this._loadingName);
            const image$ = this.stateService.currentImage$.pipe(first(), mergeMap((image) => {
                return ([exports.NavigationDirection.Next, exports.NavigationDirection.Prev].indexOf(direction) > -1 ?
                    image.sequenceEdges$ :
                    image.spatialEdges$).pipe(first(), map((status) => {
                    for (let edge of status.edges) {
                        if (edge.data.direction === direction) {
                            return edge.target;
                        }
                    }
                    return null;
                }));
            }), mergeMap((directionId) => {
                if (directionId == null) {
                    this._loadingService.stopLoading(this._loadingName);
                    return throwError(new Error(`Direction (${direction}) does not exist for current image.`));
                }
                return this._moveTo$(directionId);
            }));
            return this._makeRequest$(image$);
        }
        setFilter$(filter) {
            this._stateService.clearImages();
            return this._movedToId$.pipe(first(), mergeMap((id) => {
                if (id != null) {
                    return this._trajectoryIds$().pipe(mergeMap((ids) => {
                        return this._graphService.setFilter$(filter).pipe(mergeMap(() => {
                            return this._cacheIds$(ids);
                        }));
                    }), last());
                }
                return this._idRequested$.pipe(first(), mergeMap((requestedId) => {
                    if (requestedId != null) {
                        return this._graphService.setFilter$(filter).pipe(mergeMap(() => {
                            return this._graphService.cacheImage$(requestedId);
                        }));
                    }
                    return this._graphService.setFilter$(filter).pipe(map(() => {
                        return undefined;
                    }));
                }));
            }), map(() => {
                return undefined;
            }));
        }
        setAccessToken$(accessToken) {
            this._abortRequest("to set user token");
            this._stateService.clearImages();
            return this._movedToId$.pipe(first(), tap(() => {
                this._api.setAccessToken(accessToken);
            }), mergeMap((id) => {
                return id == null ?
                    this._graphService.reset$([]) :
                    this._trajectoryIds$().pipe(mergeMap((ids) => {
                        return this._graphService.reset$(ids).pipe(mergeMap(() => {
                            return this._cacheIds$(ids);
                        }));
                    }), last(), map(() => {
                        return undefined;
                    }));
            }));
        }
        _cacheIds$(ids) {
            const cacheImages$ = ids
                .map((id) => {
                return this._graphService.cacheImage$(id);
            });
            return from(cacheImages$).pipe(mergeAll());
        }
        _abortRequest(reason) {
            if (this._requestSubscription != null) {
                this._requestSubscription.unsubscribe();
                this._requestSubscription = null;
            }
            if (this._imageRequestSubscription != null) {
                this._imageRequestSubscription.unsubscribe();
                this._imageRequestSubscription = null;
            }
            if (this._request$ != null) {
                if (!(this._request$.isStopped || this._request$.hasError)) {
                    this._request$.error(new CancelMapillaryError(`Request aborted by a subsequent request ${reason}.`));
                }
                this._request$ = null;
            }
        }
        _makeRequest$(image$) {
            const request$ = new ReplaySubject(1);
            this._requestSubscription = request$
                .subscribe(undefined, () => { });
            this._request$ = request$;
            this._imageRequestSubscription = image$
                .subscribe((image) => {
                this._request$ = null;
                request$.next(image);
                request$.complete();
            }, (error) => {
                this._request$ = null;
                request$.error(error);
            });
            return request$;
        }
        _moveTo$(id) {
            this._idRequested$.next(id);
            return this._graphService.cacheImage$(id).pipe(tap((image) => {
                this._stateService.setImages([image]);
                this._movedToId$.next(image.id);
            }), finalize(() => {
                this._loadingService.stopLoading(this._loadingName);
            }));
        }
        _trajectoryIds$() {
            return this._stateService.currentState$.pipe(first(), map((frame) => {
                return frame.state.trajectory
                    .map((image) => {
                    return image.id;
                });
            }));
        }
    }

    class Projection {
        constructor(viewportCoords, spatial) {
            this._spatial = spatial !== null && spatial !== void 0 ? spatial : new Spatial();
            this._viewportCoords = viewportCoords !== null && viewportCoords !== void 0 ? viewportCoords : new ViewportCoords();
        }
        basicToCanvas(basicPoint, container, render, transform) {
            return this._viewportCoords
                .basicToCanvasSafe(basicPoint[0], basicPoint[1], container, transform, render.perspective);
        }
        canvasToBasic(canvasPoint, container, render, transform) {
            let basicPoint = this._viewportCoords
                .canvasToBasic(canvasPoint[0], canvasPoint[1], container, transform, render.perspective);
            if (basicPoint[0] < 0 ||
                basicPoint[0] > 1 ||
                basicPoint[1] < 0 ||
                basicPoint[1] > 1) {
                basicPoint = null;
            }
            return basicPoint;
        }
        eventToUnprojection(event, container, render, reference, transform) {
            const pixelPoint = this._viewportCoords
                .canvasPosition(event, container);
            return this.canvasToUnprojection(pixelPoint, container, render, reference, transform);
        }
        canvasToUnprojection(canvasPoint, container, render, reference, transform) {
            const canvasX = canvasPoint[0];
            const canvasY = canvasPoint[1];
            const [viewportX, viewportY] = this._viewportCoords
                .canvasToViewport(canvasX, canvasY, container);
            const point3d = new Vector3(viewportX, viewportY, 1)
                .unproject(render.perspective);
            let basicPoint = transform
                .projectBasic(point3d.toArray());
            if (basicPoint[0] < 0 ||
                basicPoint[0] > 1 ||
                basicPoint[1] < 0 ||
                basicPoint[1] > 1) {
                basicPoint = null;
            }
            const direction3d = point3d
                .clone()
                .sub(render.camera.position)
                .normalize();
            const dist = -2 / direction3d.z;
            let lngLat = null;
            if (dist > 0 && dist < 100 && !!basicPoint) {
                const point = direction3d
                    .clone()
                    .multiplyScalar(dist)
                    .add(render.camera.position);
                const [lng, lat] = enuToGeodetic(point.x, point.y, point.z, reference.lng, reference.lat, reference.alt);
                lngLat = { lat, lng };
            }
            const unprojection = {
                basicPoint: basicPoint,
                lngLat: lngLat,
                pixelPoint: [canvasX, canvasY],
            };
            return unprojection;
        }
        cameraToLngLat(render, reference) {
            const position = render.camera.position;
            const [lng, lat] = enuToGeodetic(position.x, position.y, position.z, reference.lng, reference.lat, reference.alt);
            return { lat, lng };
        }
        lngLatToCanvas(lngLat, container, render, reference) {
            const point3d = geodeticToEnu(lngLat.lng, lngLat.lat, 0, reference.lng, reference.lat, reference.alt);
            const canvas = this._viewportCoords
                .projectToCanvasSafe(point3d, container, render.perspective);
            return canvas;
        }
        distanceBetweenLngLats(lngLat1, lngLat2) {
            return this._spatial
                .distanceFromLngLat(lngLat1.lng, lngLat1.lat, lngLat2.lng, lngLat2.lat);
        }
    }

    class Observer {
        constructor(viewer, navigator, container) {
            this._subscriptions = new SubscriptionHolder();
            this._emitSubscriptions = new SubscriptionHolder();
            this._container = container;
            this._viewer = viewer;
            this._navigator = navigator;
            this._projection = new Projection();
            this._started = false;
            this._navigable$ = new Subject();
            const subs = this._subscriptions;
            // load, navigable, dataloading should always emit,
            // also when cover is activated.
            subs.push(this._navigable$
                .subscribe((navigable) => {
                const type = "navigable";
                const event = {
                    navigable,
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._navigator.loadingService.loading$
                .subscribe((loading) => {
                const type = "dataloading";
                const event = {
                    loading,
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._container.glRenderer.opaqueRender$
                .pipe(first())
                .subscribe(() => {
                const type = "load";
                const event = {
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
        }
        get started() {
            return this._started;
        }
        get navigable$() {
            return this._navigable$;
        }
        get projection() {
            return this._projection;
        }
        dispose() {
            this.stopEmit();
            this._subscriptions.unsubscribe();
        }
        project$(lngLat) {
            return combineLatest(this._container.renderService.renderCamera$, this._navigator.stateService.currentImage$, this._navigator.stateService.reference$).pipe(first(), map(([render, image, reference]) => {
                if (this._projection
                    .distanceBetweenLngLats(lngLat, image.lngLat) > 1000) {
                    return null;
                }
                const canvasPoint = this._projection.lngLatToCanvas(lngLat, this._container.container, render, reference);
                return !!canvasPoint ?
                    [Math.round(canvasPoint[0]), Math.round(canvasPoint[1])] :
                    null;
            }));
        }
        projectBasic$(basicPoint) {
            return combineLatest(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$).pipe(first(), map(([render, transform]) => {
                const canvasPoint = this._projection.basicToCanvas(basicPoint, this._container.container, render, transform);
                return !!canvasPoint ?
                    [Math.round(canvasPoint[0]), Math.round(canvasPoint[1])] :
                    null;
            }));
        }
        startEmit() {
            if (this._started) {
                return;
            }
            this._started = true;
            const subs = this._emitSubscriptions;
            subs.push(this._navigator.stateService.currentImageExternal$
                .subscribe((image) => {
                const type = "image";
                const event = {
                    image: image,
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._navigator.stateService.currentImageExternal$.pipe(switchMap((image) => {
                return image.sequenceEdges$;
            }))
                .subscribe((status) => {
                const type = "sequenceedges";
                const event = {
                    status,
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._navigator.stateService.currentImageExternal$.pipe(switchMap((image) => {
                return image.spatialEdges$;
            }))
                .subscribe((status) => {
                const type = "spatialedges";
                const event = {
                    status,
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(combineLatest(this._navigator.stateService.inMotion$, this._container.mouseService.active$, this._container.touchService.active$).pipe(map((values) => {
                return values[0] || values[1] || values[2];
            }), distinctUntilChanged())
                .subscribe((started) => {
                const type = started ? "movestart" : "moveend";
                const event = {
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._container.renderService.bearing$.pipe(auditTime(100), distinctUntilChanged((b1, b2) => {
                return Math.abs(b2 - b1) < 1;
            }))
                .subscribe((bearing) => {
                const type = "bearing";
                const event = {
                    bearing,
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            const mouseMove$ = this._container.mouseService.active$.pipe(switchMap((active) => {
                return active ?
                    empty() :
                    this._container.mouseService.mouseMove$;
            }));
            subs.push(merge(this._mapMouseEvent$("click", this._container.mouseService.staticClick$), this._mapMouseEvent$("contextmenu", this._container.mouseService.contextMenu$), this._mapMouseEvent$("dblclick", this._container.mouseService.dblClick$), this._mapMouseEvent$("mousedown", this._container.mouseService.mouseDown$), this._mapMouseEvent$("mousemove", mouseMove$), this._mapMouseEvent$("mouseout", this._container.mouseService.mouseOut$), this._mapMouseEvent$("mouseover", this._container.mouseService.mouseOver$), this._mapMouseEvent$("mouseup", this._container.mouseService.mouseUp$))
                .pipe(withLatestFrom(this._container.renderService.renderCamera$, this._navigator.stateService.reference$, this._navigator.stateService.currentTransform$, this._navigator.stateService.state$), map(([[type, event], render, reference, transform, state]) => {
                const unprojection = this._projection.eventToUnprojection(event, this._container.container, render, reference, transform);
                const basicPoint = state === State.Traversing ?
                    unprojection.basicPoint : null;
                return {
                    basicPoint,
                    lngLat: unprojection.lngLat,
                    originalEvent: event,
                    pixelPoint: unprojection.pixelPoint,
                    target: this._viewer,
                    type: type,
                };
            }))
                .subscribe((event) => {
                this._viewer.fire(event.type, event);
            }));
            subs.push(this._container.renderService.renderCamera$.pipe(distinctUntilChanged(([x1, y1], [x2, y2]) => {
                return this._closeTo(x1, x2, 1e-2) &&
                    this._closeTo(y1, y2, 1e-2);
            }, (rc) => {
                return rc.camera.position.toArray();
            }))
                .subscribe(() => {
                const type = "position";
                const event = {
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._container.renderService.renderCamera$.pipe(distinctUntilChanged(([phi1, theta1], [phi2, theta2]) => {
                return this._closeTo(phi1, phi2, 1e-3) &&
                    this._closeTo(theta1, theta2, 1e-3);
            }, (rc) => {
                return [rc.rotation.phi, rc.rotation.theta];
            }))
                .subscribe(() => {
                const type = "pov";
                const event = {
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
            subs.push(this._container.renderService.renderCamera$.pipe(distinctUntilChanged((fov1, fov2) => {
                return this._closeTo(fov1, fov2, 1e-2);
            }, (rc) => {
                return rc.perspective.fov;
            }))
                .subscribe(() => {
                const type = "fov";
                const event = {
                    target: this._viewer,
                    type,
                };
                this._viewer.fire(type, event);
            }));
        }
        stopEmit() {
            if (!this.started) {
                return;
            }
            this._emitSubscriptions.unsubscribe();
            this._started = false;
        }
        unproject$(canvasPoint) {
            return combineLatest(this._container.renderService.renderCamera$, this._navigator.stateService.reference$, this._navigator.stateService.currentTransform$).pipe(first(), map(([render, reference, transform]) => {
                const unprojection = this._projection.canvasToUnprojection(canvasPoint, this._container.container, render, reference, transform);
                return unprojection.lngLat;
            }));
        }
        unprojectBasic$(canvasPoint) {
            return combineLatest(this._container.renderService.renderCamera$, this._navigator.stateService.currentTransform$).pipe(first(), map(([render, transform]) => {
                return this._projection.canvasToBasic(canvasPoint, this._container.container, render, transform);
            }));
        }
        _closeTo(v1, v2, absoluteTolerance) {
            return Math.abs(v1 - v2) <= absoluteTolerance;
        }
        _mapMouseEvent$(type, mouseEvent$) {
            return mouseEvent$.pipe(map((event) => {
                return [type, event];
            }));
        }
    }

    class CustomRenderer {
        constructor(_container, _navigator) {
            this._container = _container;
            this._navigator = _navigator;
            this._renderers = {};
        }
        add(renderer, viewer) {
            const subs = new SubscriptionHolder();
            this._renderers[renderer.id] = { subs, renderer };
            subs.push(combineLatest([
                this._container.glRenderer.webGLRenderer$,
                this._navigator.stateService.reference$,
            ])
                .pipe(take(1))
                .subscribe(([gl, reference]) => {
                renderer.onAdd(viewer, reference, gl.getContext());
            }));
            subs.push(this._container.glRenderer.opaqueRender$
                .pipe(withLatestFrom(this._container.renderService.renderCamera$, this._container.glRenderer.webGLRenderer$))
                .subscribe(([, renderCamera, glRenderer]) => {
                const context = glRenderer.getContext();
                const viewMatrix = renderCamera.perspective.matrixWorldInverse;
                const projectionMatrix = renderCamera.perspective.projectionMatrix;
                renderer.render(context, viewMatrix.toArray(), projectionMatrix.toArray());
            }));
            subs.push(this._navigator.stateService.reference$
                .pipe(skip(1))
                .subscribe((reference) => {
                renderer.onReference(viewer, reference);
            }));
        }
        dispose(viewer) {
            for (const id of Object.keys(this._renderers)) {
                this.remove(id, viewer);
            }
        }
        has(id) {
            return id in this._renderers;
        }
        remove(id, viewer) {
            this._renderers[id].subs.unsubscribe();
            const renderer = this._renderers[id].renderer;
            delete this._renderers[id];
            this._container.glRenderer.webGLRenderer$
                .subscribe((gl) => {
                renderer.onRemove(viewer, gl.getContext());
            });
        }
    }

    class CustomCameraControls {
        constructor(_container, _navigator) {
            this._container = _container;
            this._navigator = _navigator;
            this._controls = null;
            this._subscriptions = new SubscriptionHolder();
        }
        attach(controls, viewer) {
            if (this._controls) {
                throw new MapillaryError('Custom camera controls already attached');
            }
            const attach$ = new Subject();
            const active$ = attach$
                .pipe(switchMap(() => {
                return this._navigator.stateService.state$;
            }), map((state) => {
                return state === State.Custom;
            }), distinctUntilChanged());
            const subs = this._subscriptions;
            subs.push(active$
                .pipe(startWith(false), pairwise(), withLatestFrom(this._navigator.stateService.reference$, this._container.renderService.renderCamera$))
                .subscribe(([[deactivate, activate], ref, cam]) => {
                if (activate) {
                    controls.onActivate(viewer, cam.perspective.matrixWorldInverse.toArray(), cam.perspective.projectionMatrix.toArray(), ref);
                }
                else if (deactivate) {
                    controls.onDeactivate(viewer);
                }
            }));
            subs.push(active$
                .pipe(switchMap(active => {
                return active ?
                    this._navigator.stateService.currentState$
                        .pipe(skip(1)) :
                    empty();
            }))
                .subscribe(frame => {
                controls.onAnimationFrame(viewer, frame.id);
            }));
            subs.push(active$
                .pipe(switchMap(active => {
                return active ?
                    this._navigator.stateService.reference$
                        .pipe(skip(1)) :
                    empty();
            }))
                .subscribe(ref => controls.onReference(viewer, ref)));
            subs.push(active$
                .pipe(switchMap(active => {
                return active ?
                    this._container.renderService.size$
                        .pipe(skip(1)) :
                    empty();
            }))
                .subscribe(() => controls.onResize(viewer)));
            subs.push(combineLatest([
                // Include to ensure GL renderer has been initialized
                this._container.glRenderer.webGLRenderer$,
                this._container.renderService.renderCamera$,
                this._navigator.stateService.reference$,
                this._navigator.stateService.state$,
            ])
                .pipe(first())
                .subscribe(() => {
                const projectionMatrixCallback = (projectionMatrix) => {
                    if (!this._controls ||
                        controls !== this._controls) {
                        return;
                    }
                    this._updateProjectionMatrix(projectionMatrix);
                };
                const viewMatrixCallback = (viewMatrix) => {
                    if (!this._controls ||
                        controls !== this._controls) {
                        return;
                    }
                    this._updateViewMatrix(viewMatrix);
                };
                controls.onAttach(viewer, viewMatrixCallback, projectionMatrixCallback);
                attach$.next();
                attach$.complete();
            }));
            this._controls = controls;
        }
        dispose(viewer) {
            this.detach(viewer);
        }
        detach(viewer) {
            if (!this._controls) {
                return;
            }
            this._subscriptions.unsubscribe();
            this._navigator.stateService.state$
                .subscribe(state => {
                if (state === State.Custom) {
                    this._controls.onDeactivate(viewer);
                }
                this._controls.onDetach(viewer);
                this._controls = null;
            });
        }
        _updateProjectionMatrix(projectionMatrix) {
            this._navigator.stateService.state$
                .pipe(first())
                .subscribe(state => {
                if (state !== State.Custom) {
                    const message = "Incorrect camera control mode for " +
                        "projection matrix update";
                    console.warn(message);
                    return;
                }
                this._container.renderService.projectionMatrix$
                    .next(projectionMatrix);
            });
        }
        _updateViewMatrix(viewMatrix) {
            this._navigator.stateService.state$
                .pipe(first())
                .subscribe(state => {
                if (state !== State.Custom) {
                    const message = "Incorrect camera control mode for " +
                        "view matrix update";
                    console.warn(message);
                    return;
                }
                this._navigator.stateService.setViewMatrix(viewMatrix);
            });
        }
    }

    /**
     * @class Viewer
     *
     * @classdesc The Viewer object represents the navigable image viewer.
     * Create a Viewer by specifying a container, client ID, image id and
     * other options. The viewer exposes methods and events for programmatic
     * interaction.
     *
     * In the case of asynchronous methods, MapillaryJS returns promises to
     * the results. Notifications are always emitted through JavaScript events.
     */
    class Viewer extends EventEmitter {
        /**
         * Create a new viewer instance.
         *
         * @description It is possible to initialize the viewer with or
         * without a id.
         *
         * When you want to show a specific image in the viewer from
         * the start you should initialize it with a id.
         *
         * When you do not know the first image id at implementation
         * time, e.g. in a map-viewer application you should initialize
         * the viewer without a id and call `moveTo` instead.
         *
         * When initializing with a id the viewer is bound to that id
         * until the image for that id has been successfully loaded.
         * Also, a cover with the image of the id will be shown.
         * If the data for that id can not be loaded because the id is
         * faulty or other errors occur it is not possible to navigate
         * to another id because the viewer is not navigable. The viewer
         * becomes navigable when the data for the id has been loaded and
         * the image is shown in the viewer. This way of initializing
         * the viewer is mostly for embedding in blog posts and similar
         * where one wants to show a specific image initially.
         *
         * If the viewer is initialized without a id (with null or
         * undefined) it is not bound to any particular id and it is
         * possible to move to any id with `viewer.moveTo("<my-image-id>")`.
         * If the first move to a id fails it is possible to move to another
         * id. The viewer will show a black background until a move
         * succeeds. This way of intitializing is suited for a map-viewer
         * application when the initial id is not known at implementation
         * time.
         *
         * @param {ViewerOptions} options - Optional configuration object
         * specifing Viewer's and the components' initial setup.
         *
         * @example
         * ```js
         * var viewer = new Viewer({
         *     accessToken: "<my-access-token>",
         *     container: "<my-container-id>",
         * });
         * ```
         */
        constructor(options) {
            super();
            this._navigator =
                new Navigator(options);
            this._container =
                new Container(options, this._navigator.stateService);
            this._observer =
                new Observer(this, this._navigator, this._container);
            this._componentController =
                new ComponentController(this._container, this._navigator, this._observer, options.imageId, options.component);
            this._customRenderer =
                new CustomRenderer(this._container, this._navigator);
            this._customCameraControls =
                new CustomCameraControls(this._container, this._navigator);
        }
        /**
         * Return a boolean indicating if the viewer is in a navigable state.
         *
         * @description The navigable state indicates if the viewer supports
         * moving, i.e. calling the {@link moveTo} and {@link moveDir}
         * methods or changing the authentication state,
         * i.e. calling {@link setAccessToken}. The viewer will not be in a navigable
         * state if the cover is activated and the viewer has been supplied a id.
         * When the cover is deactivated or the viewer is activated without being
         * supplied a id it will be navigable.
         *
         * @returns {boolean} Boolean indicating whether the viewer is navigable.
         */
        get isNavigable() {
            return this._componentController.navigable;
        }
        /**
         * Activate the combined panning functionality.
         *
         * @description The combined panning functionality is active by default.
         */
        activateCombinedPanning() {
            this._navigator.panService.enable();
        }
        /**
         * Activate a component.
         *
         * @param {ComponentName | FallbackComponentName} name - Name of
         * the component which will become active.
         *
         * @example
         * ```js
         * viewer.activateComponent("marker");
         * ```
         */
        activateComponent(name) {
            this._componentController.activate(name);
        }
        /**
         * Activate the cover (deactivates all other components).
         */
        activateCover() {
            this._componentController.activateCover();
        }
        /**
         * Add a custom renderer to the viewer's rendering pipeline.
         *
         * @description During a render pass, custom renderers
         * are called in the order they were added.
         *
         * @param renderer - The custom renderer implementation.
         */
        addCustomRenderer(renderer) {
            this._customRenderer.add(renderer, this);
        }
        /**
         * Attach custom camera controls to control the viewer's
         * camera pose and projection.
         *
         * @description Custom camera controls allow the API user
         * to move the viewer's camera freely and define the camera
         * projection. These camera properties are used
         * to render the viewer 3D scene directly into the
         * viewer's GL context.
         *
         * Only a single custom camera control instance can be
         * attached to the viewer. A new custom camera control
         * instance can be attached after detaching a previous
         * one.
         *
         * Set the viewer's camera controls to
         * {@link CameraControls.Custom} to activate attached
         * camera controls. If {@link CameraControls.Custom}
         * has already been set when a custom camera control
         * instance is attached, it will be activated immediately.
         *
         * Set the viewer's camera controls to any other
         * {@link CameraControls} mode to deactivate the
         * custom camera controls.
         *
         * @param controls - The custom camera controls implementation.
         *
         * @throws {MapillaryError} When camera controls attached
         * are already attached to the viewer.
         */
        attachCustomCameraControls(controls) {
            this._customCameraControls.attach(controls, this);
        }
        /**
         * Deactivate the combined panning functionality.
         *
         * @description Deactivating the combined panning functionality
         * could be needed in scenarios involving sequence only navigation.
         */
        deactivateCombinedPanning() {
            this._navigator.panService.disable();
        }
        /**
         * Deactivate a component.
         *
         * @param {ComponentName | FallbackComponentName} name - Name
         * of component which become inactive.
         *
         * @example
         * ```js
         * viewer.deactivateComponent("pointer");
         * ```
         */
        deactivateComponent(name) {
            this._componentController.deactivate(name);
        }
        /**
         * Deactivate the cover (activates all components marked as active).
         */
        deactivateCover() {
            this._componentController.deactivateCover();
        }
        /**
         * Detach a previously attached custom camera control
         * instance from the viewer.
         *
         * @description If no custom camera control instance
         * has previously been attached, calling this method
         * has no effect.
         *
         * Already attached custom camera controls need to
         * be detached before attaching another custom camera
         * control instance.
         */
        detachCustomCameraControls() {
            this._customCameraControls.detach(this);
        }
        fire(type, event) {
            super.fire(type, event);
        }
        /**
         * Get the bearing of the current viewer camera.
         *
         * @description The bearing depends on how the camera
         * is currently rotated and does not correspond
         * to the compass angle of the current image if the view
         * has been panned.
         *
         * Bearing is measured in degrees clockwise with respect to
         * north.
         *
         * @returns {Promise<number>} Promise to the bearing
         * of the current viewer camera.
         *
         * @example
         * ```js
         * viewer.getBearing().then(b => { console.log(b); });
         * ```
         */
        getBearing() {
            return new Promise((resolve, reject) => {
                this._container.renderService.bearing$.pipe(first())
                    .subscribe((bearing) => {
                    resolve(bearing);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Get the viewer's camera control mode.
         *
         * @description The camera control mode determines
         * how the camera is controlled when the viewer
         * recieves pointer and keyboard input.
         *
         * @returns {CameraControls} controls - Camera control mode.
         *
         * @example
         * ```js
         * viewer.getCameraControls().then(c => { console.log(c); });
         * ```
         */
        getCameraControls() {
            return new Promise((resolve, reject) => {
                this._navigator.stateService.state$.pipe(first())
                    .subscribe((state) => {
                    switch (state) {
                        case State.Custom:
                            resolve(exports.CameraControls.Custom);
                            break;
                        case State.Earth:
                            resolve(exports.CameraControls.Earth);
                            break;
                        default:
                            resolve(exports.CameraControls.Street);
                            break;
                    }
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Returns the viewer's canvas element.
         *
         * @description This is the element onto which the viewer renders
         * the WebGL content.
         *
         * @returns {HTMLCanvasElement} The viewer's canvas element, or
         * null or not initialized.
         */
        getCanvas() {
            return this._container.canvas;
        }
        /**
         * Returns the HTML element containing the viewer's canvas element.
         *
         * @description This is the element to which event bindings for viewer
         * interactivity (such as panning and zooming) are attached.
         *
         * @returns {HTMLDivElement} The container for the viewer's
         * canvas element.
         */
        getCanvasContainer() {
            return this._container.canvasContainer;
        }
        /**
         * Get the basic coordinates of the current image that is
         * at the center of the viewport.
         *
         * @description Basic coordinates are 2D coordinates on the [0, 1] interval
         * and have the origin point, (0, 0), at the top left corner and the
         * maximum value, (1, 1), at the bottom right corner of the original
         * image.
         *
         * @returns {Promise<number[]>} Promise to the basic coordinates
         * of the current image at the center for the viewport.
         *
         * @example
         * ```js
         * viewer.getCenter().then(c => { console.log(c); });
         * ```
         */
        getCenter() {
            return new Promise((resolve, reject) => {
                this._navigator.stateService.getCenter()
                    .subscribe((center) => {
                    resolve(center);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Get a component.
         *
         * @param {string} name - Name of component.
         * @returns {Component} The requested component.
         *
         * @example
         * ```js
         * var pointerComponent = viewer.getComponent("pointer");
         * ```
         */
        getComponent(name) {
            return this._componentController.get(name);
        }
        /**
         * Returns the viewer's containing HTML element.
         *
         * @returns {HTMLElement} The viewer's container.
         */
        getContainer() {
            return this._container.container;
        }
        /**
         * Get the viewer's current vertical field of view.
         *
         * @description The vertical field of view rendered on the viewer canvas
         * measured in degrees.
         *
         * @returns {Promise<number>} Promise to the current field of view
         * of the viewer camera.
         *
         * @example
         * ```js
         * viewer.getFieldOfView().then(fov => { console.log(fov); });
         * ```
         */
        getFieldOfView() {
            return new Promise((resolve, reject) => {
                this._container.renderService.renderCamera$.pipe(first())
                    .subscribe((rc) => {
                    resolve(rc.perspective.fov);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Get the viewer's current image.
         *
         * @returns {Promise<Image>} Promise to the current image.
         *
         * @example
         * ```js
         * viewer.getImage().then(image => { console.log(image.id); });
         * ```
         */
        getImage() {
            return new Promise((resolve, reject) => {
                this._navigator.stateService.currentImage$.pipe(first())
                    .subscribe((image) => { resolve(image); }, (error) => { reject(error); });
            });
        }
        /**
         * Get the viewer's current point of view.
         *
         * @returns {Promise<PointOfView>} Promise to the current point of view
         * of the viewer camera.
         *
         * @example
         * ```js
         * viewer.getPointOfView().then(pov => { console.log(pov); });
         * ```
         */
        getPointOfView() {
            return new Promise((resolve, reject) => {
                combineLatest(this._container.renderService.renderCamera$, this._container.renderService.bearing$).pipe(first())
                    .subscribe(([rc, bearing]) => {
                    resolve({
                        bearing: bearing,
                        tilt: rc.getTilt(),
                    });
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Get the viewer's current position
         *
         * @returns {Promise<LngLat>} Promise to the viewers's current
         * position.
         *
         * @example
         * ```js
         * viewer.getPosition().then(pos => { console.log(pos); });
         * ```
         */
        getPosition() {
            return new Promise((resolve, reject) => {
                combineLatest(this._container.renderService.renderCamera$, this._navigator.stateService.reference$).pipe(first())
                    .subscribe(([render, reference]) => {
                    resolve(this._observer.projection.cameraToLngLat(render, reference));
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Get the image's current zoom level.
         *
         * @returns {Promise<number>} Promise to the viewers's current
         * zoom level.
         *
         * @example
         * ```js
         * viewer.getZoom().then(z => { console.log(z); });
         * ```
         */
        getZoom() {
            return new Promise((resolve, reject) => {
                this._navigator.stateService.getZoom()
                    .subscribe((zoom) => {
                    resolve(zoom);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Check if a custom renderer has been added to the viewer's
         * rendering pipeline.
         *
         * @param {string} id - Unique id of the custom renderer.
         * @returns {boolean} Value indicating whether the customer
         * renderer has been added.
         */
        hasCustomRenderer(rendererId) {
            return this._customRenderer.has(rendererId);
        }
        /**
         * Navigate in a given direction.
         *
         * @param {NavigationDirection} direction - Direction in which which to move.
         * @returns {Promise<Image>} Promise to the image that was navigated to.
         * @throws If the current image does not have the edge direction
         * or the edges has not yet been cached.
         * @throws Propagates any IO errors to the caller.
         * @throws When viewer is not navigable.
         * @throws {@link CancelMapillaryError} When a subsequent move request
         * is made before the move dir call has completed.
         *
         * @example
         * ```js
         * viewer.moveDir(NavigationDirection.Next).then(
         *     image => { console.log(image); },
         *     error => { console.error(error); });
         * ```
         */
        moveDir(direction) {
            const moveDir$ = this.isNavigable ?
                this._navigator.moveDir$(direction) :
                throwError(new Error("Calling moveDir is not supported when viewer is not navigable."));
            return new Promise((resolve, reject) => {
                moveDir$.subscribe((image) => {
                    resolve(image);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Navigate to a given image id.
         *
         * @param {string} imageId - Id of the image to move to.
         * @returns {Promise<Image>} Promise to the image that was navigated to.
         * @throws Propagates any IO errors to the caller.
         * @throws When viewer is not navigable.
         * @throws {@link CancelMapillaryError} When a subsequent
         * move request is made before the move to id call has completed.
         *
         * @example
         * ```js
         * viewer.moveTo("<my-image-id>").then(
         *     image => { console.log(image); },
         *     error => { console.error(error); });
         * ```
         */
        moveTo(imageId) {
            const moveTo$ = this.isNavigable ?
                this._navigator.moveTo$(imageId) :
                throwError(new Error("Calling moveTo is not supported when viewer is not navigable."));
            return new Promise((resolve, reject) => {
                moveTo$.subscribe((image) => {
                    resolve(image);
                }, (error) => {
                    reject(error);
                });
            });
        }
        off(type, handler) {
            super.off(type, handler);
        }
        on(type, handler) {
            super.on(type, handler);
        }
        /**
         * Project geodetic coordinates to canvas pixel coordinates.
         *
         * @description The geodetic coordinates may not always correspond to pixel
         * coordinates, e.g. if the geodetic coordinates have a position behind the
         * viewer camera. In the case of no correspondence the returned value will
         * be `null`.
         *
         * If the distance from the viewer camera position to the provided
         * longitude-latitude is more than 1000 meters `null` will be returned.
         *
         * The projection is performed from the ground plane, i.e.
         * the altitude with respect to the ground plane for the geodetic
         * point is zero.
         *
         * Note that whenever the camera moves, the result of the method will be
         * different.
         *
         * @param {LngLat} lngLat - Geographical coordinates to project.
         * @returns {Promise<Array<number>>} Promise to the pixel coordinates corresponding
         * to the lngLat.
         *
         * @example
         * ```js
         * viewer.project({ lat: 0, lng: 0 })
         *     .then(pixelPoint => {
         *          if (!pixelPoint) {
         *              console.log("no correspondence");
         *          }
         *
         *          console.log(pixelPoint);
         *     });
         * ```
         */
        project(lngLat) {
            return new Promise((resolve, reject) => {
                this._observer.project$(lngLat)
                    .subscribe((pixelPoint) => {
                    resolve(pixelPoint);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Project basic image coordinates for the current image to canvas pixel
         * coordinates.
         *
         * @description The basic image coordinates may not always correspond to a
         * pixel point that lies in the visible area of the viewer container. In the
         * case of no correspondence the returned value can be `null`.
         *
         *
         * @param {Array<number>} basicPoint - Basic images coordinates to project.
         * @returns {Promise<Array<number>>} Promise to the pixel coordinates corresponding
         * to the basic image point.
         *
         * @example
         * ```js
         * viewer.projectFromBasic([0.3, 0.7])
         *     .then(pixelPoint => { console.log(pixelPoint); });
         * ```
         */
        projectFromBasic(basicPoint) {
            return new Promise((resolve, reject) => {
                this._observer.projectBasic$(basicPoint)
                    .subscribe((pixelPoint) => {
                    resolve(pixelPoint);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Clean up and release all internal resources associated with
         * this viewer.
         *
         * @description This includes DOM elements, event bindings, and
         * WebGL resources.
         *
         * Use this method when you are done using the viewer and wish to
         * ensure that it no longer consumes browser resources. Afterwards,
         * you must not call any other methods on the viewer.
         *
         * @fires remove
         *
         * @example
         * ```js
         * viewer.remove();
         * ```
         */
        remove() {
            this._customRenderer.dispose(this);
            this._customCameraControls.dispose(this);
            this._observer.dispose();
            this._componentController.remove();
            this._navigator.dispose();
            this._container.remove();
            const type = "remove";
            const event = {
                target: this,
                type,
            };
            this.fire(type, event);
        }
        /**
         * Remove a custom renderer from the viewer's rendering pipeline.
         *
         * @param id - Unique id of the custom renderer.
         */
        removeCustomRenderer(rendererId) {
            this._customRenderer.remove(rendererId, this);
        }
        /**
         * Detect the viewer's new width and height and resize it
         * manually.
         *
         * @description The components will also detect the viewer's
         * new size and resize their rendered elements if needed.
         *
         * When the {@link ViewerOptions.trackResize} option is
         * set to true, the viewer will automatically resize
         * when the browser window is resized. If any other
         * custom behavior is preferred, the option should be set
         * to false and the {@link Viewer.resize} method should
         * be called on demand.
         *
         * @example
         * ```js
         * viewer.resize();
         * ```
         */
        resize() {
            this._container.renderService.resize$.next();
        }
        /**
         * Set the viewer's camera control mode.
         *
         * @description The camera control mode determines
         * how the camera is controlled when the viewer
         * recieves pointer and keyboard input.
         *
         * Changing the camera control mode is not possible
         * when the slider component is active and attempts
         * to do so will be ignored.
         *
         * @param {CameraControls} controls - Camera control mode.
         *
         * @example
         * ```js
         * viewer.setCameraControls(CameraControls.Street);
         * ```
         */
        setCameraControls(controls) {
            const state = cameraControlsToState(controls);
            if (state === State.Traversing) {
                this._navigator.stateService.traverse();
            }
            else if (state === State.Earth) {
                this._navigator.stateService.earth();
            }
            else if (state === State.Custom) {
                this._navigator.stateService.custom();
            }
            else {
                console.warn(`Unsupported camera control transition (${controls})`);
            }
        }
        /**
         * Set the basic coordinates of the current image to be in the
         * center of the viewport.
         *
         * @description Basic coordinates are 2D coordinates on the [0, 1] interval
         * and has the origin point, (0, 0), at the top left corner and the
         * maximum value, (1, 1), at the bottom right corner of the original
         * image.
         *
         * @param {number[]} The basic coordinates of the current
         * image to be at the center for the viewport.
         *
         * @example
         * ```js
         * viewer.setCenter([0.5, 0.5]);
         * ```
         */
        setCenter(center) {
            this._navigator.stateService.setCenter(center);
        }
        /**
         * Set the viewer's current vertical field of view.
         *
         * @description Sets the vertical field of view rendered
         * on the viewer canvas measured in degrees. The value
         * will be clamped to be able to set a valid zoom level
         * based on the projection model of the current image and
         * the viewer's current render mode.
         *
         * @param {number} fov - Vertical field of view in degrees.
         *
         * @example
         * ```js
         * viewer.setFieldOfView(45);
         * ```
         */
        setFieldOfView(fov) {
            this._container.renderService.renderCamera$.pipe(first())
                .subscribe((rc) => {
                const zoom = rc.fovToZoom(fov);
                this._navigator.stateService.setZoom(zoom);
            });
        }
        /**
         * Set the filter selecting images to use when calculating
         * the spatial edges.
         *
         * @description The following filter types are supported:
         *
         * Comparison
         *
         * `["==", key, value]` equality: `image[key] = value`
         *
         * `["!=", key, value]` inequality: `image[key] ≠ value`
         *
         * `["<", key, value]` less than: `image[key] < value`
         *
         * `["<=", key, value]` less than or equal: `image[key] ≤ value`
         *
         * `[">", key, value]` greater than: `image[key] > value`
         *
         * `[">=", key, value]` greater than or equal: `image[key] ≥ value`
         *
         * Set membership
         *
         * `["in", key, v0, ..., vn]` set inclusion: `image[key] ∈ {v0, ..., vn}`
         *
         * `["!in", key, v0, ..., vn]` set exclusion: `image[key] ∉ {v0, ..., vn}`
         *
         * Combining
         *
         * `["all", f0, ..., fn]` logical `AND`: `f0 ∧ ... ∧ fn`
         *
         * A key must be a string that identifies a property name of a
         * simple {@link Image} property, i.e. a key of the {@link FilterKey}
         * type. A value must be a string, number, or
         * boolean. Strictly-typed comparisons are used. The values
         * `f0, ..., fn` of the combining filter must be filter expressions.
         *
         * Clear the filter by setting it to null or empty array.
         *
         * Commonly used filter properties (see the {@link Image} class
         * documentation for a full list of properties that can be used
         * in a filter) are shown the the example code.
         *
         * @param {FilterExpression} filter - The filter expression.
         * @returns {Promise<void>} Promise that resolves after filter is applied.
         *
         * @example
         * ```js
         * // Examples
         * viewer.setFilter(["==", "cameraType", "spherical"]);
         * viewer.setFilter([">=", "capturedAt", <my-time-stamp>]);
         * viewer.setFilter(["in", "sequenceId", "<sequence-id-1>", "<sequence-id-2>"]);
         * ```
         */
        setFilter(filter) {
            return new Promise((resolve, reject) => {
                this._navigator.setFilter$(filter)
                    .subscribe(() => {
                    resolve(undefined);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Set the viewer's render mode.
         *
         * @param {RenderMode} renderMode - Render mode.
         *
         * @example
         * ```js
         * viewer.setRenderMode(RenderMode.Letterbox);
         * ```
         */
        setRenderMode(renderMode) {
            this._container.renderService.renderMode$.next(renderMode);
        }
        /**
         * Set the viewer's transition mode.
         *
         * @param {TransitionMode} transitionMode - Transition mode.
         *
         * @example
         * ```js
         * viewer.setTransitionMode(TransitionMode.Instantaneous);
         * ```
         */
        setTransitionMode(transitionMode) {
            this._navigator.stateService.setTransitionMode(transitionMode);
        }
        /**
         * Set an access token for authenticated API requests of protected
         * resources.
         *
         * The token may be a user access token or a client access token.
         *
         * @description When the supplied user token is null or undefined,
         * any previously set user bearer token will be cleared and the
         * viewer will make unauthenticated requests.
         *
         * Calling setAccessToken aborts all outstanding move requests.
         * The promises of those move requests will be rejected with a
         * {@link CancelMapillaryError} the rejections need to be caught.
         *
         * Calling setAccessToken also resets the complete viewer cache
         * so it should not be called repeatedly.
         *
         * @param {string} [accessToken] accessToken - Optional user
         * access token or client access token.
         * @returns {Promise<void>} Promise that resolves after token
         * is set.
         *
         * @throws When viewer is not navigable.
         *
         * @example
         * ```js
         * viewer.setAccessToken("<my access token>")
         *     .then(() => { console.log("user token set"); });
         * ```
         */
        setAccessToken(accessToken) {
            const setAccessToken$ = this.isNavigable ?
                this._navigator.setAccessToken$(accessToken) :
                throwError(new Error("Calling setAccessToken is not supported when viewer is not navigable."));
            return new Promise((resolve, reject) => {
                setAccessToken$
                    .subscribe(() => {
                    resolve(undefined);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Set the image's current zoom level.
         *
         * @description Possible zoom level values are on the [0, 3] interval.
         * Zero means zooming out to fit the image to the view whereas three
         * shows the highest level of detail.
         *
         * @param {number} The image's current zoom level.
         *
         * @example
         * ```js
         * viewer.setZoom(2);
         * ```
         */
        setZoom(zoom) {
            this._navigator.stateService.setZoom(zoom);
        }
        /**
         * Trigger the rendering of a single frame.
         *
         * @description Use this method with custom renderers to
         * force the viewer to rerender when the custom content
         * changes. Calling this multiple times before the next
         * frame is rendered will still result in only a single
         * frame being rendered.
         */
        triggerRerender() {
            this._container.glRenderer.triggerRerender();
        }
        /**
         * Unproject canvas pixel coordinates to geodetic
         * coordinates.
         *
         * @description The pixel point may not always correspond to geodetic
         * coordinates. In the case of no correspondence the returned value will
         * be `null`.
         *
         * The unprojection to a lngLat will be performed towards the ground plane, i.e.
         * the altitude with respect to the ground plane for the returned lngLat is zero.
         *
         * @param {Array<number>} pixelPoint - Pixel coordinates to unproject.
         * @returns {Promise<LngLat>} Promise to the lngLat corresponding to the pixel point.
         *
         * @example
         * ```js
         * viewer.unproject([100, 100])
         *     .then(lngLat => { console.log(lngLat); });
         * ```
         */
        unproject(pixelPoint) {
            return new Promise((resolve, reject) => {
                this._observer.unproject$(pixelPoint)
                    .subscribe((lngLat) => {
                    resolve(lngLat);
                }, (error) => {
                    reject(error);
                });
            });
        }
        /**
         * Unproject canvas pixel coordinates to basic image coordinates for the
         * current image.
         *
         * @description The pixel point may not always correspond to basic image
         * coordinates. In the case of no correspondence the returned value will
         * be `null`.
         *
         * @param {Array<number>} pixelPoint - Pixel coordinates to unproject.
         * @returns {Promise<LngLat>} Promise to the basic coordinates corresponding
         * to the pixel point.
         *
         * @example
         * ```js
         * viewer.unprojectToBasic([100, 100])
         *     .then(basicPoint => { console.log(basicPoint); });
         * ```
         */
        unprojectToBasic(pixelPoint) {
            return new Promise((resolve, reject) => {
                this._observer.unprojectBasic$(pixelPoint)
                    .subscribe((basicPoint) => {
                    resolve(basicPoint);
                }, (error) => {
                    reject(error);
                });
            });
        }
    }

    /**
     * Internal bootstrap
     *
     * This is a workaround to make the CommonJS unit testing
     * work with Jest. Once Jest/Node supports ES6 modules
     * fully this should be removed. GeoRBush and UnitBezier
     * are registered here only to avoid loading them during
     * unit tests.
     */
    Graph.register(GeoRBush);
    MarkerSet.register(GeoRBush);
    TraversingState.register(unitbezier);
    ComponentService.registerCover(CoverComponent);
    ComponentService.register(AttributionComponent);
    ComponentService.register(BearingComponent);
    ComponentService.register(CacheComponent);
    ComponentService.register(DirectionComponent);
    ComponentService.register(ImageComponent);
    ComponentService.register(KeyboardComponent);
    ComponentService.register(MarkerComponent);
    ComponentService.register(PointerComponent);
    ComponentService.register(PopupComponent);
    ComponentService.register(SequenceComponent);
    ComponentService.register(SliderComponent);
    ComponentService.register(SpatialComponent);
    ComponentService.register(TagComponent);
    ComponentService.register(ZoomComponent);
    ComponentService.register(ImageFallbackComponent);
    ComponentService.register(NavigationFallbackComponent);

    exports.ArgumentMapillaryError = ArgumentMapillaryError;
    exports.BearingComponent = BearingComponent;
    exports.CacheComponent = CacheComponent;
    exports.CancelMapillaryError = CancelMapillaryError;
    exports.CircleMarker = CircleMarker;
    exports.Component = Component;
    exports.DataProviderBase = DataProviderBase;
    exports.DirectionComponent = DirectionComponent;
    exports.DragPanHandler = DragPanHandler;
    exports.ExtremePointTag = ExtremePointTag;
    exports.Geometry = Geometry;
    exports.GeometryProviderBase = GeometryProviderBase;
    exports.GeometryTagError = GeometryTagError;
    exports.GraphDataProvider = GraphDataProvider;
    exports.GraphMapillaryError = GraphMapillaryError;
    exports.Image = Image$1;
    exports.KeyPlayHandler = KeyPlayHandler;
    exports.KeySequenceNavigationHandler = KeySequenceNavigationHandler;
    exports.KeySpatialNavigationHandler = KeySpatialNavigationHandler;
    exports.KeyZoomHandler = KeyZoomHandler;
    exports.KeyboardComponent = KeyboardComponent;
    exports.MapillaryError = MapillaryError;
    exports.Marker = Marker;
    exports.MarkerComponent = MarkerComponent;
    exports.OutlineTag = OutlineTag;
    exports.PointGeometry = PointGeometry;
    exports.PointerComponent = PointerComponent;
    exports.PointsGeometry = PointsGeometry;
    exports.PolygonGeometry = PolygonGeometry;
    exports.Popup = Popup;
    exports.PopupComponent = PopupComponent;
    exports.RectGeometry = RectGeometry;
    exports.S2GeometryProvider = S2GeometryProvider;
    exports.ScrollZoomHandler = ScrollZoomHandler;
    exports.SequenceComponent = SequenceComponent;
    exports.SimpleMarker = SimpleMarker;
    exports.SliderComponent = SliderComponent;
    exports.SpatialComponent = SpatialComponent;
    exports.SpotTag = SpotTag;
    exports.Tag = Tag;
    exports.TagComponent = TagComponent;
    exports.TouchZoomHandler = TouchZoomHandler;
    exports.VertexGeometry = VertexGeometry;
    exports.Viewer = Viewer;
    exports.ZoomComponent = ZoomComponent;
    exports.decompress = decompress;
    exports.enuToGeodetic = enuToGeodetic;
    exports.fetchArrayBuffer = fetchArrayBuffer;
    exports.geodeticToEnu = geodeticToEnu;
    exports.isFallbackSupported = isFallbackSupported;
    exports.isSupported = isSupported;
    exports.readMeshPbf = readMeshPbf;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=mapillary.unminified.js.map