(function () {

	const _zee = new THREE.Vector3(0, 0, 1);

	const _euler = new THREE.Euler();

	const _q0 = new THREE.Quaternion();

	const _q1 = new THREE.Quaternion(- Math.sqrt(0.5), 0, 0, Math.sqrt(0.5)); // - PI/2 around the x-axis


	const _changeEvent = {
		type: 'change'
	};

	class DeviceOrientationControls extends THREE.EventDispatcher {

		constructor(object) {

			super();

			if (window.isSecureContext === false) {

				console.error('THREE.DeviceOrientationControls: DeviceOrientationEvent is only available in secure contexts (https)');

			}

			const scope = this;
			const EPS = 0.000001;
			const lastQuaternion = new THREE.Quaternion();
			this.object = object;
			this.object.rotation.reorder('YXZ');
			this.enabled = true;
			this.deviceOrientation = {};
			this.screenOrientation = 0;
			this.alphaOffset = 0; // radians

			const onDeviceOrientationChangeEvent = function (event) {

				scope.deviceOrientation = event;

			};

			const onScreenOrientationChangeEvent = function () {

				scope.screenOrientation = window.orientation || 0;

			}; // The angles alpha, beta and gamma form a set of intrinsic Tait-Bryan angles of type Z-X'-Y''


			const setObjectQuaternion = function (quaternion, alpha, beta, gamma, orient) {

				_euler.set(beta, alpha, - gamma, 'YXZ'); // 'ZXY' for the device, but 'YXZ' for us


				quaternion.setFromEuler(_euler); // orient the device

				quaternion.multiply(_q1); // camera looks out the back of the device, not the top

				quaternion.multiply(_q0.setFromAxisAngle(_zee, - orient)); // adjust for screen orientation

			};

			this.connect = function () {

				onScreenOrientationChangeEvent(); // run once on load
				// iOS 13+

				if (window.DeviceOrientationEvent !== undefined && typeof window.DeviceOrientationEvent.requestPermission === 'function') {

					window.DeviceOrientationEvent.requestPermission().then(function (response) {

						if (response == 'granted') {

							window.addEventListener('orientationchange', onScreenOrientationChangeEvent);
							window.addEventListener('deviceorientation', onDeviceOrientationChangeEvent);

						}

					}).catch(function (error) {

						console.error('THREE.DeviceOrientationControls: Unable to use DeviceOrientation API:', error);

					});

				} else {

					window.addEventListener('orientationchange', onScreenOrientationChangeEvent);
					window.addEventListener('deviceorientation', onDeviceOrientationChangeEvent);

				}

				scope.enabled = true;

			};

			this.disconnect = function () {

				window.removeEventListener('orientationchange', onScreenOrientationChangeEvent);
				window.removeEventListener('deviceorientation', onDeviceOrientationChangeEvent);
				scope.enabled = false;

			};

			this.update = function () {

				if (scope.enabled === false) return;
				const device = scope.deviceOrientation;

				if (device) {

					const alpha = device.alpha ? THREE.MathUtils.degToRad(device.alpha) + scope.alphaOffset : 0; // Z

					const beta = device.beta ? THREE.MathUtils.degToRad(device.beta) : 0; // X'

					const gamma = device.gamma ? THREE.MathUtils.degToRad(device.gamma) : 0; // Y''

					const orient = scope.screenOrientation ? THREE.MathUtils.degToRad(scope.screenOrientation) : 0; // O

					setObjectQuaternion(scope.object.quaternion, alpha, beta, gamma, orient);

					if (8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {

						lastQuaternion.copy(scope.object.quaternion);
						scope.dispatchEvent(_changeEvent);

					}

				}

			};

			this.dispose = function () {

				scope.disconnect();

			};

			this.connect();

		}

	}

	THREE.DeviceOrientationControls = DeviceOrientationControls;

})();
