v-viewer转化成cdn文件,优化包
This commit is contained in:
aixianling
826
ui/lib/cdn/v-viewer/1.7.4/v-viewer.js
Normal file
826
ui/lib/cdn/v-viewer/1.7.4/v-viewer.js
Normal file
@@ -0,0 +1,826 @@
|
||||
import Viewer from "viewerjs";
|
||||
import Vue from "vue";
|
||||
|
||||
export { default as Viewer } from "viewerjs";
|
||||
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
|
||||
var freeGlobal$1 = freeGlobal;
|
||||
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
|
||||
var root = freeGlobal$1 || freeSelf || Function("return this")();
|
||||
var root$1 = root;
|
||||
var Symbol$1 = root$1.Symbol;
|
||||
var Symbol$2 = Symbol$1;
|
||||
var objectProto$8 = Object.prototype;
|
||||
var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
|
||||
var nativeObjectToString$1 = objectProto$8.toString;
|
||||
var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : void 0;
|
||||
function getRawTag(value) {
|
||||
var isOwn = hasOwnProperty$6.call(value, symToStringTag$1), tag = value[symToStringTag$1];
|
||||
try {
|
||||
value[symToStringTag$1] = void 0;
|
||||
var unmasked = true;
|
||||
} catch (e) {
|
||||
}
|
||||
var result = nativeObjectToString$1.call(value);
|
||||
if (unmasked) {
|
||||
if (isOwn) {
|
||||
value[symToStringTag$1] = tag;
|
||||
} else {
|
||||
delete value[symToStringTag$1];
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
var objectProto$7 = Object.prototype;
|
||||
var nativeObjectToString = objectProto$7.toString;
|
||||
function objectToString(value) {
|
||||
return nativeObjectToString.call(value);
|
||||
}
|
||||
var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
|
||||
var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
|
||||
function baseGetTag(value) {
|
||||
if (value == null) {
|
||||
return value === void 0 ? undefinedTag : nullTag;
|
||||
}
|
||||
return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
|
||||
}
|
||||
function isObjectLike(value) {
|
||||
return value != null && typeof value == "object";
|
||||
}
|
||||
var symbolTag = "[object Symbol]";
|
||||
function isSymbol(value) {
|
||||
return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
|
||||
}
|
||||
var isArray = Array.isArray;
|
||||
var isArray$1 = isArray;
|
||||
var reWhitespace = /\s/;
|
||||
function trimmedEndIndex(string) {
|
||||
var index2 = string.length;
|
||||
while (index2-- && reWhitespace.test(string.charAt(index2))) {
|
||||
}
|
||||
return index2;
|
||||
}
|
||||
var reTrimStart = /^\s+/;
|
||||
function baseTrim(string) {
|
||||
return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
|
||||
}
|
||||
function isObject(value) {
|
||||
var type = typeof value;
|
||||
return value != null && (type == "object" || type == "function");
|
||||
}
|
||||
var NAN = 0 / 0;
|
||||
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
||||
var reIsBinary = /^0b[01]+$/i;
|
||||
var reIsOctal = /^0o[0-7]+$/i;
|
||||
var freeParseInt = parseInt;
|
||||
function toNumber(value) {
|
||||
if (typeof value == "number") {
|
||||
return value;
|
||||
}
|
||||
if (isSymbol(value)) {
|
||||
return NAN;
|
||||
}
|
||||
if (isObject(value)) {
|
||||
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
||||
value = isObject(other) ? other + "" : other;
|
||||
}
|
||||
if (typeof value != "string") {
|
||||
return value === 0 ? value : +value;
|
||||
}
|
||||
value = baseTrim(value);
|
||||
var isBinary = reIsBinary.test(value);
|
||||
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
|
||||
}
|
||||
function identity(value) {
|
||||
return value;
|
||||
}
|
||||
var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
|
||||
function isFunction(value) {
|
||||
if (!isObject(value)) {
|
||||
return false;
|
||||
}
|
||||
var tag = baseGetTag(value);
|
||||
return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
|
||||
}
|
||||
var coreJsData = root$1["__core-js_shared__"];
|
||||
var coreJsData$1 = coreJsData;
|
||||
var maskSrcKey = function() {
|
||||
var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || "");
|
||||
return uid ? "Symbol(src)_1." + uid : "";
|
||||
}();
|
||||
function isMasked(func) {
|
||||
return !!maskSrcKey && maskSrcKey in func;
|
||||
}
|
||||
var funcProto$1 = Function.prototype;
|
||||
var funcToString$1 = funcProto$1.toString;
|
||||
function toSource(func) {
|
||||
if (func != null) {
|
||||
try {
|
||||
return funcToString$1.call(func);
|
||||
} catch (e) {
|
||||
}
|
||||
try {
|
||||
return func + "";
|
||||
} catch (e) {
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
||||
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
||||
var funcProto = Function.prototype, objectProto$6 = Object.prototype;
|
||||
var funcToString = funcProto.toString;
|
||||
var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
|
||||
var reIsNative = RegExp(
|
||||
"^" + funcToString.call(hasOwnProperty$5).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
|
||||
);
|
||||
function baseIsNative(value) {
|
||||
if (!isObject(value) || isMasked(value)) {
|
||||
return false;
|
||||
}
|
||||
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
|
||||
return pattern.test(toSource(value));
|
||||
}
|
||||
function getValue(object, key) {
|
||||
return object == null ? void 0 : object[key];
|
||||
}
|
||||
function getNative(object, key) {
|
||||
var value = getValue(object, key);
|
||||
return baseIsNative(value) ? value : void 0;
|
||||
}
|
||||
function apply(func, thisArg, args) {
|
||||
switch (args.length) {
|
||||
case 0:
|
||||
return func.call(thisArg);
|
||||
case 1:
|
||||
return func.call(thisArg, args[0]);
|
||||
case 2:
|
||||
return func.call(thisArg, args[0], args[1]);
|
||||
case 3:
|
||||
return func.call(thisArg, args[0], args[1], args[2]);
|
||||
}
|
||||
return func.apply(thisArg, args);
|
||||
}
|
||||
var HOT_COUNT = 800, HOT_SPAN = 16;
|
||||
var nativeNow = Date.now;
|
||||
function shortOut(func) {
|
||||
var count = 0, lastCalled = 0;
|
||||
return function() {
|
||||
var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
|
||||
lastCalled = stamp;
|
||||
if (remaining > 0) {
|
||||
if (++count >= HOT_COUNT) {
|
||||
return arguments[0];
|
||||
}
|
||||
} else {
|
||||
count = 0;
|
||||
}
|
||||
return func.apply(void 0, arguments);
|
||||
};
|
||||
}
|
||||
function constant(value) {
|
||||
return function() {
|
||||
return value;
|
||||
};
|
||||
}
|
||||
var defineProperty = function() {
|
||||
try {
|
||||
var func = getNative(Object, "defineProperty");
|
||||
func({}, "", {});
|
||||
return func;
|
||||
} catch (e) {
|
||||
}
|
||||
}();
|
||||
var defineProperty$1 = defineProperty;
|
||||
var baseSetToString = !defineProperty$1 ? identity : function(func, string) {
|
||||
return defineProperty$1(func, "toString", {
|
||||
"configurable": true,
|
||||
"enumerable": false,
|
||||
"value": constant(string),
|
||||
"writable": true
|
||||
});
|
||||
};
|
||||
var baseSetToString$1 = baseSetToString;
|
||||
var setToString = shortOut(baseSetToString$1);
|
||||
var setToString$1 = setToString;
|
||||
var MAX_SAFE_INTEGER$1 = 9007199254740991;
|
||||
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
||||
function isIndex(value, length) {
|
||||
var type = typeof value;
|
||||
length = length == null ? MAX_SAFE_INTEGER$1 : length;
|
||||
return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
|
||||
}
|
||||
function baseAssignValue(object, key, value) {
|
||||
if (key == "__proto__" && defineProperty$1) {
|
||||
defineProperty$1(object, key, {
|
||||
"configurable": true,
|
||||
"enumerable": true,
|
||||
"value": value,
|
||||
"writable": true
|
||||
});
|
||||
} else {
|
||||
object[key] = value;
|
||||
}
|
||||
}
|
||||
function eq(value, other) {
|
||||
return value === other || value !== value && other !== other;
|
||||
}
|
||||
var objectProto$5 = Object.prototype;
|
||||
var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
|
||||
function assignValue(object, key, value) {
|
||||
var objValue = object[key];
|
||||
if (!(hasOwnProperty$4.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
|
||||
baseAssignValue(object, key, value);
|
||||
}
|
||||
}
|
||||
function copyObject(source, props, object, customizer) {
|
||||
var isNew = !object;
|
||||
object || (object = {});
|
||||
var index2 = -1, length = props.length;
|
||||
while (++index2 < length) {
|
||||
var key = props[index2];
|
||||
var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
|
||||
if (newValue === void 0) {
|
||||
newValue = source[key];
|
||||
}
|
||||
if (isNew) {
|
||||
baseAssignValue(object, key, newValue);
|
||||
} else {
|
||||
assignValue(object, key, newValue);
|
||||
}
|
||||
}
|
||||
return object;
|
||||
}
|
||||
var nativeMax$1 = Math.max;
|
||||
function overRest(func, start, transform) {
|
||||
start = nativeMax$1(start === void 0 ? func.length - 1 : start, 0);
|
||||
return function() {
|
||||
var args = arguments, index2 = -1, length = nativeMax$1(args.length - start, 0), array = Array(length);
|
||||
while (++index2 < length) {
|
||||
array[index2] = args[start + index2];
|
||||
}
|
||||
index2 = -1;
|
||||
var otherArgs = Array(start + 1);
|
||||
while (++index2 < start) {
|
||||
otherArgs[index2] = args[index2];
|
||||
}
|
||||
otherArgs[start] = transform(array);
|
||||
return apply(func, this, otherArgs);
|
||||
};
|
||||
}
|
||||
function baseRest(func, start) {
|
||||
return setToString$1(overRest(func, start, identity), func + "");
|
||||
}
|
||||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||||
function isLength(value) {
|
||||
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
||||
}
|
||||
function isArrayLike(value) {
|
||||
return value != null && isLength(value.length) && !isFunction(value);
|
||||
}
|
||||
function isIterateeCall(value, index2, object) {
|
||||
if (!isObject(object)) {
|
||||
return false;
|
||||
}
|
||||
var type = typeof index2;
|
||||
if (type == "number" ? isArrayLike(object) && isIndex(index2, object.length) : type == "string" && index2 in object) {
|
||||
return eq(object[index2], value);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function createAssigner(assigner) {
|
||||
return baseRest(function(object, sources) {
|
||||
var index2 = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
|
||||
customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
|
||||
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
||||
customizer = length < 3 ? void 0 : customizer;
|
||||
length = 1;
|
||||
}
|
||||
object = Object(object);
|
||||
while (++index2 < length) {
|
||||
var source = sources[index2];
|
||||
if (source) {
|
||||
assigner(object, source, index2, customizer);
|
||||
}
|
||||
}
|
||||
return object;
|
||||
});
|
||||
}
|
||||
var objectProto$4 = Object.prototype;
|
||||
function isPrototype(value) {
|
||||
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$4;
|
||||
return value === proto;
|
||||
}
|
||||
function baseTimes(n, iteratee) {
|
||||
var index2 = -1, result = Array(n);
|
||||
while (++index2 < n) {
|
||||
result[index2] = iteratee(index2);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
var argsTag$1 = "[object Arguments]";
|
||||
function baseIsArguments(value) {
|
||||
return isObjectLike(value) && baseGetTag(value) == argsTag$1;
|
||||
}
|
||||
var objectProto$3 = Object.prototype;
|
||||
var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
|
||||
var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
|
||||
var isArguments = baseIsArguments(function() {
|
||||
return arguments;
|
||||
}()) ? baseIsArguments : function(value) {
|
||||
return isObjectLike(value) && hasOwnProperty$3.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
|
||||
};
|
||||
var isArguments$1 = isArguments;
|
||||
function stubFalse() {
|
||||
return false;
|
||||
}
|
||||
var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
|
||||
var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
|
||||
var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
|
||||
var Buffer = moduleExports$1 ? root$1.Buffer : void 0;
|
||||
var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
|
||||
var isBuffer = nativeIsBuffer || stubFalse;
|
||||
var isBuffer$1 = isBuffer;
|
||||
var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", weakMapTag = "[object WeakMap]";
|
||||
var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
|
||||
var typedArrayTags = {};
|
||||
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
|
||||
typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
||||
function baseIsTypedArray(value) {
|
||||
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
|
||||
}
|
||||
function baseUnary(func) {
|
||||
return function(value) {
|
||||
return func(value);
|
||||
};
|
||||
}
|
||||
var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
|
||||
var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
|
||||
var moduleExports = freeModule && freeModule.exports === freeExports;
|
||||
var freeProcess = moduleExports && freeGlobal$1.process;
|
||||
var nodeUtil = function() {
|
||||
try {
|
||||
var types = freeModule && freeModule.require && freeModule.require("util").types;
|
||||
if (types) {
|
||||
return types;
|
||||
}
|
||||
return freeProcess && freeProcess.binding && freeProcess.binding("util");
|
||||
} catch (e) {
|
||||
}
|
||||
}();
|
||||
var nodeUtil$1 = nodeUtil;
|
||||
var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray;
|
||||
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
|
||||
var isTypedArray$1 = isTypedArray;
|
||||
var objectProto$2 = Object.prototype;
|
||||
var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
|
||||
function arrayLikeKeys(value, inherited) {
|
||||
var isArr = isArray$1(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
|
||||
for (var key in value) {
|
||||
if ((inherited || hasOwnProperty$2.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
|
||||
result.push(key);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function overArg(func, transform) {
|
||||
return function(arg) {
|
||||
return func(transform(arg));
|
||||
};
|
||||
}
|
||||
var nativeKeys = overArg(Object.keys, Object);
|
||||
var nativeKeys$1 = nativeKeys;
|
||||
var objectProto$1 = Object.prototype;
|
||||
var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
|
||||
function baseKeys(object) {
|
||||
if (!isPrototype(object)) {
|
||||
return nativeKeys$1(object);
|
||||
}
|
||||
var result = [];
|
||||
for (var key in Object(object)) {
|
||||
if (hasOwnProperty$1.call(object, key) && key != "constructor") {
|
||||
result.push(key);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function keys(object) {
|
||||
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
|
||||
}
|
||||
var objectProto = Object.prototype;
|
||||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||||
var assign = createAssigner(function(object, source) {
|
||||
if (isPrototype(source) || isArrayLike(source)) {
|
||||
copyObject(source, keys(source), object);
|
||||
return;
|
||||
}
|
||||
for (var key in source) {
|
||||
if (hasOwnProperty.call(source, key)) {
|
||||
assignValue(object, key, source[key]);
|
||||
}
|
||||
}
|
||||
});
|
||||
var assign$1 = assign;
|
||||
var now = function() {
|
||||
return root$1.Date.now();
|
||||
};
|
||||
var now$1 = now;
|
||||
var FUNC_ERROR_TEXT = "Expected a function";
|
||||
var nativeMax = Math.max, nativeMin = Math.min;
|
||||
function debounce(func, wait, options) {
|
||||
var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
|
||||
if (typeof func != "function") {
|
||||
throw new TypeError(FUNC_ERROR_TEXT);
|
||||
}
|
||||
wait = toNumber(wait) || 0;
|
||||
if (isObject(options)) {
|
||||
leading = !!options.leading;
|
||||
maxing = "maxWait" in options;
|
||||
maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
|
||||
trailing = "trailing" in options ? !!options.trailing : trailing;
|
||||
}
|
||||
function invokeFunc(time) {
|
||||
var args = lastArgs, thisArg = lastThis;
|
||||
lastArgs = lastThis = void 0;
|
||||
lastInvokeTime = time;
|
||||
result = func.apply(thisArg, args);
|
||||
return result;
|
||||
}
|
||||
function leadingEdge(time) {
|
||||
lastInvokeTime = time;
|
||||
timerId = setTimeout(timerExpired, wait);
|
||||
return leading ? invokeFunc(time) : result;
|
||||
}
|
||||
function remainingWait(time) {
|
||||
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
|
||||
return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
|
||||
}
|
||||
function shouldInvoke(time) {
|
||||
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
|
||||
return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
|
||||
}
|
||||
function timerExpired() {
|
||||
var time = now$1();
|
||||
if (shouldInvoke(time)) {
|
||||
return trailingEdge(time);
|
||||
}
|
||||
timerId = setTimeout(timerExpired, remainingWait(time));
|
||||
}
|
||||
function trailingEdge(time) {
|
||||
timerId = void 0;
|
||||
if (trailing && lastArgs) {
|
||||
return invokeFunc(time);
|
||||
}
|
||||
lastArgs = lastThis = void 0;
|
||||
return result;
|
||||
}
|
||||
function cancel() {
|
||||
if (timerId !== void 0) {
|
||||
clearTimeout(timerId);
|
||||
}
|
||||
lastInvokeTime = 0;
|
||||
lastArgs = lastCallTime = lastThis = timerId = void 0;
|
||||
}
|
||||
function flush() {
|
||||
return timerId === void 0 ? result : trailingEdge(now$1());
|
||||
}
|
||||
function debounced() {
|
||||
var time = now$1(), isInvoking = shouldInvoke(time);
|
||||
lastArgs = arguments;
|
||||
lastThis = this;
|
||||
lastCallTime = time;
|
||||
if (isInvoking) {
|
||||
if (timerId === void 0) {
|
||||
return leadingEdge(lastCallTime);
|
||||
}
|
||||
if (maxing) {
|
||||
clearTimeout(timerId);
|
||||
timerId = setTimeout(timerExpired, wait);
|
||||
return invokeFunc(lastCallTime);
|
||||
}
|
||||
}
|
||||
if (timerId === void 0) {
|
||||
timerId = setTimeout(timerExpired, wait);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
debounced.cancel = cancel;
|
||||
debounced.flush = flush;
|
||||
return debounced;
|
||||
}
|
||||
var render = function() {
|
||||
var _vm = this;
|
||||
var _h = _vm.$createElement;
|
||||
var _c = _vm._self._c || _h;
|
||||
return _c("div", [_vm._t("default", null, { "images": _vm.images, "options": _vm.options })], 2);
|
||||
};
|
||||
var staticRenderFns = [];
|
||||
function normalizeComponent(scriptExports, render2, staticRenderFns2, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
|
||||
var options = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
|
||||
if (render2) {
|
||||
options.render = render2;
|
||||
options.staticRenderFns = staticRenderFns2;
|
||||
options._compiled = true;
|
||||
}
|
||||
if (functionalTemplate) {
|
||||
options.functional = true;
|
||||
}
|
||||
if (scopeId) {
|
||||
options._scopeId = "data-v-" + scopeId;
|
||||
}
|
||||
var hook;
|
||||
if (moduleIdentifier) {
|
||||
hook = function(context) {
|
||||
context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
|
||||
if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
|
||||
context = __VUE_SSR_CONTEXT__;
|
||||
}
|
||||
if (injectStyles) {
|
||||
injectStyles.call(this, context);
|
||||
}
|
||||
if (context && context._registeredComponents) {
|
||||
context._registeredComponents.add(moduleIdentifier);
|
||||
}
|
||||
};
|
||||
options._ssrRegister = hook;
|
||||
} else if (injectStyles) {
|
||||
hook = shadowMode ? function() {
|
||||
injectStyles.call(
|
||||
this,
|
||||
(options.functional ? this.parent : this).$root.$options.shadowRoot
|
||||
);
|
||||
} : injectStyles;
|
||||
}
|
||||
if (hook) {
|
||||
if (options.functional) {
|
||||
options._injectStyles = hook;
|
||||
var originalRender = options.render;
|
||||
options.render = function renderWithStyleInjection(h, context) {
|
||||
hook.call(context);
|
||||
return originalRender(h, context);
|
||||
};
|
||||
} else {
|
||||
var existing = options.beforeCreate;
|
||||
options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
|
||||
}
|
||||
}
|
||||
return {
|
||||
exports: scriptExports,
|
||||
options
|
||||
};
|
||||
}
|
||||
const __vue2_script = {
|
||||
props: {
|
||||
images: {
|
||||
type: Array
|
||||
},
|
||||
rebuild: {
|
||||
type: Boolean,
|
||||
default: false
|
||||
},
|
||||
trigger: {},
|
||||
options: {
|
||||
type: Object
|
||||
}
|
||||
},
|
||||
data() {
|
||||
return {};
|
||||
},
|
||||
computed: {},
|
||||
watch: {
|
||||
images() {
|
||||
this.$nextTick(() => {
|
||||
this.onChange();
|
||||
});
|
||||
},
|
||||
trigger: {
|
||||
handler() {
|
||||
this.$nextTick(() => {
|
||||
this.onChange();
|
||||
});
|
||||
},
|
||||
deep: true
|
||||
},
|
||||
options: {
|
||||
handler() {
|
||||
this.$nextTick(() => {
|
||||
this.rebuildViewer();
|
||||
});
|
||||
},
|
||||
deep: true
|
||||
}
|
||||
},
|
||||
mounted() {
|
||||
this.createViewer();
|
||||
},
|
||||
unmounted() {
|
||||
this.destroyViewer();
|
||||
},
|
||||
methods: {
|
||||
onChange() {
|
||||
if (this.rebuild) {
|
||||
this.rebuildViewer();
|
||||
} else {
|
||||
this.updateViewer();
|
||||
}
|
||||
},
|
||||
rebuildViewer() {
|
||||
this.destroyViewer();
|
||||
this.createViewer();
|
||||
},
|
||||
updateViewer() {
|
||||
if (this.$viewer) {
|
||||
this.$viewer.update();
|
||||
this.$emit("inited", this.$viewer);
|
||||
} else {
|
||||
this.createViewer();
|
||||
}
|
||||
},
|
||||
destroyViewer() {
|
||||
this.$viewer && this.$viewer.destroy();
|
||||
},
|
||||
createViewer() {
|
||||
this.$viewer = new Viewer(this.$el, this.options);
|
||||
this.$emit("inited", this.$viewer);
|
||||
}
|
||||
}
|
||||
};
|
||||
const __cssModules = {};
|
||||
var __component__ = /* @__PURE__ */ normalizeComponent(
|
||||
__vue2_script,
|
||||
render,
|
||||
staticRenderFns,
|
||||
false,
|
||||
__vue2_injectStyles,
|
||||
null,
|
||||
null,
|
||||
null
|
||||
);
|
||||
function __vue2_injectStyles(context) {
|
||||
for (let o in __cssModules) {
|
||||
this[o] = __cssModules[o];
|
||||
}
|
||||
}
|
||||
var component = /* @__PURE__ */ function() {
|
||||
return __component__.exports;
|
||||
}();
|
||||
const directive = ({ name = "viewer", debug = false } = {}) => {
|
||||
function createViewer(el, options, rebuild = false, observer = false) {
|
||||
Vue.nextTick(() => {
|
||||
if (observer && !imageDiff(el))
|
||||
return;
|
||||
if (rebuild || !el[`$${name}`]) {
|
||||
destroyViewer(el);
|
||||
el[`$${name}`] = new Viewer(el, options);
|
||||
log("Viewer created");
|
||||
} else {
|
||||
el[`$${name}`].update();
|
||||
log("Viewer updated");
|
||||
}
|
||||
});
|
||||
}
|
||||
function imageDiff(el) {
|
||||
const imageContent = el.innerHTML.match(/<img([\w\W]+?)[\\/]?>/g);
|
||||
const viewerImageText = imageContent ? imageContent.join("") : void 0;
|
||||
if (el.__viewerImageDiffCache === viewerImageText) {
|
||||
log("Element change detected, but image(s) has not changed");
|
||||
return false;
|
||||
} else {
|
||||
log("Image change detected");
|
||||
el.__viewerImageDiffCache = viewerImageText;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
function createObserver(el, options, debouncedCreateViewer, rebuild) {
|
||||
destroyObserver(el);
|
||||
const MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver;
|
||||
if (!MutationObserver) {
|
||||
log("Observer not supported");
|
||||
return;
|
||||
}
|
||||
const observer = new MutationObserver((mutations) => {
|
||||
mutations.forEach((mutation) => {
|
||||
log(`Viewer mutation:${mutation.type}`);
|
||||
debouncedCreateViewer(el, options, rebuild, true);
|
||||
});
|
||||
});
|
||||
const config = { attributes: true, childList: true, characterData: true, subtree: true };
|
||||
observer.observe(el, config);
|
||||
el.__viewerMutationObserver = observer;
|
||||
log("Observer created");
|
||||
}
|
||||
function createWatcher(el, { expression }, vnode, debouncedCreateViewer) {
|
||||
const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
|
||||
if (!expression || !simplePathRE.test(expression)) {
|
||||
log("Only simple dot-delimited paths can create watcher");
|
||||
return;
|
||||
}
|
||||
el.__viewerUnwatch = vnode.context.$watch(expression, (newVal, oldVal) => {
|
||||
log("Change detected by watcher: ", expression);
|
||||
debouncedCreateViewer(el, newVal, true);
|
||||
}, {
|
||||
deep: true
|
||||
});
|
||||
log("Watcher created, expression: ", expression);
|
||||
}
|
||||
function destroyViewer(el) {
|
||||
if (!el[`$${name}`]) {
|
||||
return;
|
||||
}
|
||||
el[`$${name}`].destroy();
|
||||
delete el[`$${name}`];
|
||||
log("Viewer destroyed");
|
||||
}
|
||||
function destroyObserver(el) {
|
||||
if (!el.__viewerMutationObserver) {
|
||||
return;
|
||||
}
|
||||
el.__viewerMutationObserver.disconnect();
|
||||
delete el.__viewerMutationObserver;
|
||||
log("Observer destroyed");
|
||||
}
|
||||
function destroyWatcher(el) {
|
||||
if (!el.__viewerUnwatch) {
|
||||
return;
|
||||
}
|
||||
el.__viewerUnwatch();
|
||||
delete el.__viewerUnwatch;
|
||||
log("Watcher destroyed");
|
||||
}
|
||||
function log() {
|
||||
debug && console.log(...arguments);
|
||||
}
|
||||
const directive2 = {
|
||||
bind(el, binding, vnode) {
|
||||
log("Viewer bind");
|
||||
const debouncedCreateViewer = debounce(createViewer, 50);
|
||||
debouncedCreateViewer(el, binding.value);
|
||||
createWatcher(el, binding, vnode, debouncedCreateViewer);
|
||||
if (!binding.modifiers.static) {
|
||||
createObserver(el, binding.value, debouncedCreateViewer, binding.modifiers.rebuild);
|
||||
}
|
||||
},
|
||||
unbind(el, binding) {
|
||||
log("Viewer unbind");
|
||||
destroyObserver(el);
|
||||
destroyWatcher(el);
|
||||
destroyViewer(el);
|
||||
}
|
||||
};
|
||||
return directive2;
|
||||
};
|
||||
const api = ({ images = [], options = {} } = {}) => {
|
||||
options = assign$1(options, {
|
||||
inline: false
|
||||
});
|
||||
const ViewerToken = Vue.extend({
|
||||
render(h) {
|
||||
return h(
|
||||
"div",
|
||||
{
|
||||
style: {
|
||||
display: "none"
|
||||
},
|
||||
class: ["__viewer-token"]
|
||||
},
|
||||
images.map((attr) => {
|
||||
return h(
|
||||
"img",
|
||||
{
|
||||
attrs: typeof attr === "string" ? { src: attr } : attr
|
||||
}
|
||||
);
|
||||
})
|
||||
);
|
||||
}
|
||||
});
|
||||
const token = new ViewerToken();
|
||||
token.$mount();
|
||||
document.body.appendChild(token.$el);
|
||||
const $viewer = new Viewer(token.$el, options);
|
||||
const $destroy = $viewer.destroy.bind($viewer);
|
||||
$viewer.destroy = function() {
|
||||
$destroy();
|
||||
token.$destroy();
|
||||
document.body.removeChild(token.$el);
|
||||
return $viewer;
|
||||
};
|
||||
$viewer.show();
|
||||
token.$el.addEventListener("hidden", function() {
|
||||
if (this.viewer === $viewer) {
|
||||
$viewer.destroy();
|
||||
}
|
||||
});
|
||||
return $viewer;
|
||||
};
|
||||
var index = {
|
||||
install(Vue2, { name = "viewer", debug = false, defaultOptions } = {}) {
|
||||
Viewer.setDefaults(defaultOptions);
|
||||
Vue2.component(name, assign$1(component, { name }));
|
||||
Vue2.directive(name, directive({ name, debug }));
|
||||
Vue2.prototype[`$${name}Api`] = api;
|
||||
},
|
||||
setDefaults(defaultOptions) {
|
||||
Viewer.setDefaults(defaultOptions);
|
||||
}
|
||||
};
|
||||
export { api, component, index as default, directive };
|
||||
Reference in New Issue
Block a user