deploy: v0.12 fix 存档key名

node_modules/screenfull/dist/screenfull.d.ts

@@ -0,0 +1,172 @@
+/// <reference lib="dom"/>
+
+declare namespace screenfull {
+	type RawEventNames = {
+		readonly requestFullscreen: string;
+		readonly exitFullscreen: string;
+		readonly fullscreenElement: string;
+		readonly fullscreenEnabled: string;
+		readonly fullscreenchange: string;
+		readonly fullscreenerror: string;
+	};
+
+	type EventName = 'change' | 'error';
+
+	interface Screenfull {
+		/**
+		Whether fullscreen is active.
+		*/
+		readonly isFullscreen: boolean;
+
+		/**
+		The element currently in fullscreen, otherwise `null`.
+		*/
+		readonly element: Element | null;
+
+		/**
+		Whether you are allowed to enter fullscreen. If your page is inside an `<iframe>` you will need to add a `allowfullscreen` attribute (+ `webkitallowfullscreen` and `mozallowfullscreen`).
+
+		@example
+		```
+		if (screenfull.isEnabled) {
+			screenfull.request();
+		}
+		```
+		*/
+		readonly isEnabled: true;
+
+		/**
+		Exposes the raw properties (prefixed if needed) used internally.
+		*/
+		raw: RawEventNames;
+
+		/**
+		Make an element fullscreen.
+
+		If your page is inside an `<iframe>` you will need to add a `allowfullscreen` attribute (+ `webkitallowfullscreen` and `mozallowfullscreen`).
+
+		Keep in mind that the browser will only enter fullscreen when initiated by user events like click, touch, key.
+
+		@param element - Default is `<html>`. If called with another element than the currently active, it will switch to that if it's a descendant.
+		@param options - [`FullscreenOptions`](https://developer.mozilla.org/en-US/docs/Web/API/FullscreenOptions).
+		@returns A promise that resolves after the element enters fullscreen.
+
+		@example
+		```
+		// Fullscreen the page
+		document.getElementById('button').addEventListener('click', () => {
+			if (screenfull.isEnabled) {
+				screenfull.request();
+			} else {
+				// Ignore or do something else
+			}
+		});
+
+		// Fullscreen an element
+		const element = document.getElementById('target');
+
+		document.getElementById('button').addEventListener('click', () => {
+			if (screenfull.isEnabled) {
+				screenfull.request(element);
+			}
+		});
+
+		// Fullscreen an element with options
+		const element = document.getElementById('target');
+
+		document.getElementById('button').addEventListener('click', () => {
+			if (screenfull.isEnabled) {
+				screenfull.request(element, {navigationUI: 'hide'});
+			}
+		});
+
+		// Fullscreen an element with jQuery
+		const element = $('#target')[0]; // Get DOM element from jQuery collection
+
+		$('#button').on('click', () => {
+			if (screenfull.isEnabled) {
+				screenfull.request(element);
+			}
+		});
+		```
+		*/
+		request(element?: Element, options?: FullscreenOptions): Promise<void>;
+
+		/**
+		Brings you out of fullscreen.
+
+		@returns A promise that resolves after the element exits fullscreen.
+		*/
+		exit(): Promise<void>;
+
+		/**
+		Requests fullscreen if not active, otherwise exits.
+
+		@param element - Default is `<html>`. If called with another element than the currently active, it will switch to that if it's a descendant.
+		@param options - [`FullscreenOptions`](https://developer.mozilla.org/en-US/docs/Web/API/FullscreenOptions).
+		@returns A promise that resolves after the element enters/exits fullscreen.
+
+		@example
+		```
+		// Toggle fullscreen on a image with jQuery
+
+		$('img').on('click', event => {
+			if (screenfull.isEnabled) {
+				screenfull.toggle(event.target);
+			}
+		});
+		```
+		*/
+		toggle(element?: Element, options?: FullscreenOptions): Promise<void>;
+
+		/**
+		Add a listener for when the browser switches in and out of fullscreen or when there is an error.
+
+		@example
+		```
+		// Detect fullscreen change
+		if (screenfull.isEnabled) {
+			screenfull.on('change', () => {
+				console.log('Am I fullscreen?', screenfull.isFullscreen ? 'Yes' : 'No');
+			});
+		}
+
+		// Detect fullscreen error
+		if (screenfull.isEnabled) {
+			screenfull.on('error', event => {
+				console.error('Failed to enable fullscreen', event);
+			});
+		}
+		```
+		*/
+		on(name: EventName, handler: (event: Event) => void): void;
+
+		/**
+		Remove a previously registered event listener.
+
+		@example
+		```
+		screenfull.off('change', callback);
+		```
+		*/
+		off(name: EventName, handler: (event: Event) => void): void;
+
+		/**
+		Alias for `.on('change', function)`.
+		*/
+		onchange(handler: (event: Event) => void): void;
+
+		/**
+		Alias for `.on('error', function)`.
+		*/
+		onerror(handler: (event: Event) => void): void;
+	}
+}
+
+/**
+Simple wrapper for cross-browser usage of the JavaScript [Fullscreen API](https://developer.mozilla.org/en/DOM/Using_full-screen_mode), which lets you bring the page or any element into fullscreen. Smoothens out the browser implementation differences, so you don't have to.
+*/
+declare const screenfull: screenfull.Screenfull;
+
+export = screenfull;
+export as namespace screenfull;

node_modules/screenfull/dist/screenfull.js

@@ -0,0 +1,184 @@
+/*!
+* screenfull
+* v5.2.0 - 2021-11-03
+* (c) Sindre Sorhus; MIT License
+*/
+(function () {
+	'use strict';
+
+	var document = typeof window !== 'undefined' && typeof window.document !== 'undefined' ? window.document : {};
+	var isCommonjs = typeof module !== 'undefined' && module.exports;
+
+	var fn = (function () {
+		var val;
+
+		var fnMap = [
+			[
+				'requestFullscreen',
+				'exitFullscreen',
+				'fullscreenElement',
+				'fullscreenEnabled',
+				'fullscreenchange',
+				'fullscreenerror'
+			],
+			// New WebKit
+			[
+				'webkitRequestFullscreen',
+				'webkitExitFullscreen',
+				'webkitFullscreenElement',
+				'webkitFullscreenEnabled',
+				'webkitfullscreenchange',
+				'webkitfullscreenerror'
+
+			],
+			// Old WebKit
+			[
+				'webkitRequestFullScreen',
+				'webkitCancelFullScreen',
+				'webkitCurrentFullScreenElement',
+				'webkitCancelFullScreen',
+				'webkitfullscreenchange',
+				'webkitfullscreenerror'
+
+			],
+			[
+				'mozRequestFullScreen',
+				'mozCancelFullScreen',
+				'mozFullScreenElement',
+				'mozFullScreenEnabled',
+				'mozfullscreenchange',
+				'mozfullscreenerror'
+			],
+			[
+				'msRequestFullscreen',
+				'msExitFullscreen',
+				'msFullscreenElement',
+				'msFullscreenEnabled',
+				'MSFullscreenChange',
+				'MSFullscreenError'
+			]
+		];
+
+		var i = 0;
+		var l = fnMap.length;
+		var ret = {};
+
+		for (; i < l; i++) {
+			val = fnMap[i];
+			if (val && val[1] in document) {
+				for (i = 0; i < val.length; i++) {
+					ret[fnMap[0][i]] = val[i];
+				}
+				return ret;
+			}
+		}
+
+		return false;
+	})();
+
+	var eventNameMap = {
+		change: fn.fullscreenchange,
+		error: fn.fullscreenerror
+	};
+
+	var screenfull = {
+		request: function (element, options) {
+			return new Promise(function (resolve, reject) {
+				var onFullScreenEntered = function () {
+					this.off('change', onFullScreenEntered);
+					resolve();
+				}.bind(this);
+
+				this.on('change', onFullScreenEntered);
+
+				element = element || document.documentElement;
+
+				var returnPromise = element[fn.requestFullscreen](options);
+
+				if (returnPromise instanceof Promise) {
+					returnPromise.then(onFullScreenEntered).catch(reject);
+				}
+			}.bind(this));
+		},
+		exit: function () {
+			return new Promise(function (resolve, reject) {
+				if (!this.isFullscreen) {
+					resolve();
+					return;
+				}
+
+				var onFullScreenExit = function () {
+					this.off('change', onFullScreenExit);
+					resolve();
+				}.bind(this);
+
+				this.on('change', onFullScreenExit);
+
+				var returnPromise = document[fn.exitFullscreen]();
+
+				if (returnPromise instanceof Promise) {
+					returnPromise.then(onFullScreenExit).catch(reject);
+				}
+			}.bind(this));
+		},
+		toggle: function (element, options) {
+			return this.isFullscreen ? this.exit() : this.request(element, options);
+		},
+		onchange: function (callback) {
+			this.on('change', callback);
+		},
+		onerror: function (callback) {
+			this.on('error', callback);
+		},
+		on: function (event, callback) {
+			var eventName = eventNameMap[event];
+			if (eventName) {
+				document.addEventListener(eventName, callback, false);
+			}
+		},
+		off: function (event, callback) {
+			var eventName = eventNameMap[event];
+			if (eventName) {
+				document.removeEventListener(eventName, callback, false);
+			}
+		},
+		raw: fn
+	};
+
+	if (!fn) {
+		if (isCommonjs) {
+			module.exports = {isEnabled: false};
+		} else {
+			window.screenfull = {isEnabled: false};
+		}
+
+		return;
+	}
+
+	Object.defineProperties(screenfull, {
+		isFullscreen: {
+			get: function () {
+				return Boolean(document[fn.fullscreenElement]);
+			}
+		},
+		element: {
+			enumerable: true,
+			get: function () {
+				return document[fn.fullscreenElement];
+			}
+		},
+		isEnabled: {
+			enumerable: true,
+			get: function () {
+				// Coerce to boolean in case of old WebKit
+				return Boolean(document[fn.fullscreenEnabled]);
+			}
+		}
+	});
+
+	if (isCommonjs) {
+		module.exports = screenfull;
+	} else {
+		window.screenfull = screenfull;
+	}
+})();