Files
integral-resell/h5/static/js/chunk-vendors.4d47960d.readable.js

623 lines
18 KiB
JavaScript
Raw Normal View History

// ============================================
// 反编译后的可读版本
// 原文件: chunk-vendors.4d47960d.js
// 文件: Webpack第三方库打包文件
// 大小: 1.18MB (1,181,721 bytes)
// 说明: 包含所有第三方依赖库
// ============================================
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([
["chunk-vendors"],
{
// ==================== 核心工具模块 ====================
/**
* 模块 00c2: Array indexOf实现
* 用于不支持原生indexOf的环境
*/
"00c2": function(module, exports, require) {
"use strict";
var arrayPush = require("bb80"); // 数组push方法
var hasOwnProperty = require("338c"); // hasOwnProperty检查
var toIndexedObject = require("f660"); // 转索引对象
var indexOf = require("036b").indexOf; // indexOf方法
var hiddenKeys = require("11bf"); // 隐藏键
var push = arrayPush([].push);
module.exports = function(object, names) {
var key;
var result = toIndexedObject(object);
var index = 0;
var keys = [];
// 遍历对象
for (key in result) {
if (!hasOwnProperty(hiddenKeys, key) &&
hasOwnProperty(result, key)) {
push(keys, key);
}
}
// 遍历传入的names
while (names.length > index) {
if (hasOwnProperty(result, key = names[index++])) {
if (~indexOf(keys, key)) {
push(keys, key);
}
}
}
return keys;
};
},
/**
* 模块 00ca: Object.getOwnPropertyNames polyfill
* 获取对象自身的所有属性名
*/
"00ca": function(module, exports, require) {
var internalObjectKeys = require("56c8");
var enumBugKeys = require("da1d");
var hiddenKeys = enumBugKeys.concat("length", "prototype");
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
return internalObjectKeys(O, hiddenKeys);
};
},
// ==================== 加密相关模块 ====================
/**
* 模块 0116: HMAC实现
* Hash-based Message Authentication Code
*/
"0116": function(module, exports, require) {
"use strict";
var inherits = require("2c2e");
var Legacy = require("610c");
var Transform = require("cfef");
var Buffer = require("5f79").Buffer;
var md5 = require("1177");
var rmd160 = require("2d81");
var sha = require("25a4");
var zeroBuffer = Buffer.alloc(128);
/**
* HMAC构造函数
* @param {string} alg - 算法名称
* @param {Buffer} key - 密钥
*/
function Hmac(alg, key) {
Transform.call(this, "digest");
if (typeof key === "string") {
key = Buffer.from(key);
}
var blocksize = (alg === "sha512" || alg === "sha384") ? 128 : 64;
this._alg = alg;
this._key = key;
// 如果key长度大于blocksize先hash
if (key.length > blocksize) {
var hash = (alg === "rmd160") ? new rmd160() : sha(alg);
key = hash.update(key).digest();
} else if (key.length < blocksize) {
// 如果key长度小于blocksize填充0
key = Buffer.concat([key, zeroBuffer], blocksize);
}
// 创建ipad和opad
var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
var opad = this._opad = Buffer.allocUnsafe(blocksize);
for (var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 0x36; // XOR with 0x36
opad[i] = key[i] ^ 0x5C; // XOR with 0x5C
}
this._hash = (alg === "rmd160") ? new rmd160() : sha(alg);
this._hash.update(ipad);
}
inherits(Hmac, Transform);
Hmac.prototype._update = function(data) {
this._hash.update(data);
};
Hmac.prototype._final = function() {
var innerHash = this._hash.digest();
var hash = (this._alg === "rmd160") ? new rmd160() : sha(this._alg);
return hash.update(this._opad).update(innerHash).digest();
};
module.exports = function createHmac(alg, key) {
alg = alg.toLowerCase();
if (alg === "rmd160" || alg === "ripemd160") {
return new Hmac("rmd160", key);
}
if (alg === "md5") {
return new Legacy(md5, key);
}
return new Hmac(alg, key);
};
},
/**
* 模块 0168: Cipher基类
* 加密/解密的基础类
*/
"0168": function(module, exports, require) {
"use strict";
var assert = require("d3c2");
/**
* Cipher构造函数
* @param {Object} options - 配置选项
*/
function Cipher(options) {
this.options = options;
this.type = this.options.type;
this.blockSize = 8;
this._init();
this.buffer = new Array(this.blockSize);
this.bufferOff = 0;
}
module.exports = Cipher;
Cipher.prototype._init = function() {
// 子类实现
};
/**
* 更新数据
* @param {Array} data - 输入数据
*/
Cipher.prototype.update = function(data) {
if (data.length === 0) {
return [];
}
if (this.type === "decrypt") {
return this._updateDecrypt(data);
} else {
return this._updateEncrypt(data);
}
};
/**
* 缓冲数据
*/
Cipher.prototype._buffer = function(data, off) {
var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
for (var i = 0; i < min; i++) {
this.buffer[this.bufferOff + i] = data[off + i];
}
this.bufferOff += min;
return min;
};
/**
* 刷新缓冲区
*/
Cipher.prototype._flushBuffer = function(out, off) {
this._update(this.buffer, 0, out, off);
this.bufferOff = 0;
return this.blockSize;
};
},
// ==================== uni-simple-router 路由库 ====================
/**
* 模块 607: uni-simple-router 主入口
* 完整的路由库实现
*/
"607": function(module, exports, require) {
"use strict";
var __createBinding = (Object.create ? function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, {
enumerable: true,
get: function() { return m[k]; }
});
} : function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __exportStar = function(m, exports) {
for (var p in m) {
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) {
__createBinding(exports, m, p);
}
}
};
Object.defineProperty(exports, "__esModule", { value: true });
// 导出所有模块
exports.createRouter = void 0;
exports.RouterMount = void 0;
exports.runtimeQuit = void 0;
__exportStar(require("366"), exports); // 常量定义
__exportStar(require("309"), exports); // 类型定义
var registerLoddingPage = require("814");
Object.defineProperty(exports, "runtimeQuit", {
enumerable: true,
get: function() {
return registerLoddingPage.runtimeQuit;
}
});
var createRouter_1 = require("963");
Object.defineProperty(exports, "RouterMount", {
enumerable: true,
get: function() {
return createRouter_1.RouterMount;
}
});
Object.defineProperty(exports, "createRouter", {
enumerable: true,
get: function() {
return createRouter_1.createRouter;
}
});
},
/**
* 模块 366: 路由常量定义
*/
"366": function(module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.hookToggle = void 0;
exports.navtypeToggle = void 0;
exports.rewriteMethodToggle = void 0;
// 钩子类型切换
var hookToggle;
(function(hookToggle) {
hookToggle["beforeHooks"] = "beforeEach";
hookToggle["afterHooks"] = "afterEach";
hookToggle["enterHooks"] = "beforeEnter";
})(hookToggle = exports.hookToggle || (exports.hookToggle = {}));
// 导航类型切换
var navtypeToggle;
(function(navtypeToggle) {
navtypeToggle["push"] = "navigateTo";
navtypeToggle["replace"] = "redirectTo";
navtypeToggle["replaceAll"] = "reLaunch";
navtypeToggle["pushTab"] = "switchTab";
navtypeToggle["back"] = "navigateBack";
})(navtypeToggle = exports.navtypeToggle || (exports.navtypeToggle = {}));
// 方法重写映射
var rewriteMethodToggle;
(function(rewriteMethodToggle) {
rewriteMethodToggle["navigateTo"] = "push";
rewriteMethodToggle["navigate"] = "push";
rewriteMethodToggle["redirectTo"] = "replace";
rewriteMethodToggle["reLaunch"] = "replaceAll";
rewriteMethodToggle["switchTab"] = "pushTab";
rewriteMethodToggle["navigateBack"] = "back";
})(rewriteMethodToggle = exports.rewriteMethodToggle || (exports.rewriteMethodToggle = {}));
},
/**
* 模块 963: 创建路由器
*/
"963": function(module, exports, require) {
"use strict";
var __assign = (Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
});
Object.defineProperty(exports, "__esModule", { value: true });
exports.createRouter = void 0;
exports.RouterMount = void 0;
var baseConfig = require("282");
var utils = require("789");
var registerHooks = require("662");
var mixins = require("460");
var navjump = require("890");
var rewriteMethod = require("314");
/**
* 创建路由器实例
* @param {Object} options - 路由配置
*/
function createRouter(options) {
var config = utils.assertNewOptions(options);
var router = {
// 配置选项
options: config,
// 挂载队列
mount: [],
// Vue实例
Vue: null,
// 代理钩子依赖
proxyHookDeps: baseConfig.proxyHookDeps,
// App主实例
appMain: {},
// 进入路径
enterPath: "",
// 当前路由
$route: null,
// 锁定状态
$lockStatus: false,
// 路由映射
routesMap: {},
// 生命周期
lifeCycle: registerHooks.registerRouterHooks(
baseConfig.lifeCycle,
config
),
// ========== 导航方法 ==========
/**
* Push导航
* @param {Object|string} location - 目标位置
*/
push: function(location) {
navjump.lockNavjump(location, router, "push");
},
/**
* Replace导航
* @param {Object|string} location - 目标位置
*/
replace: function(location) {
navjump.lockNavjump(location, router, "replace");
},
/**
* ReplaceAll导航
* @param {Object|string} location - 目标位置
*/
replaceAll: function(location) {
navjump.lockNavjump(location, router, "replaceAll");
},
/**
* PushTab导航
* @param {Object|string} location - 目标位置
*/
pushTab: function(location) {
navjump.lockNavjump(location, router, "pushTab");
},
/**
* 返回导航
* @param {number} delta - 返回层数
* @param {Object} options - 选项
*/
back: function(delta, options) {
if (delta === void 0) delta = 1;
if (utils.getDataType(options) !== "[object Object]") {
options = { from: "navigateBack" };
} else if (!Reflect.has(options, "from")) {
options = __assign(__assign({}, options), { from: "navigateBack" });
}
navjump.lockNavjump(delta + "", router, "back", void 0, options);
},
/**
* 强制触发守卫
* @param {string} NAVTYPE - 导航类型
* @param {boolean} passthrough - 是否穿透
*/
forceGuardEach: function(NAVTYPE, passthrough) {
navjump.forceGuardEach(router, NAVTYPE, passthrough);
},
// ========== 路由守卫 ==========
/**
* 前置守卫
* @param {Function} fn - 守卫函数
*/
beforeEach: function(fn) {
registerHooks.registerEachHooks(router, "beforeHooks", fn);
},
/**
* 后置守卫
* @param {Function} fn - 守卫函数
*/
afterEach: function(fn) {
registerHooks.registerEachHooks(router, "afterHooks", fn);
},
/**
* 安装到Vue
* @param {Vue} Vue - Vue构造函数
*/
install: function(Vue) {
router.Vue = Vue;
// 重写uni方法
rewriteMethod.rewriteMethod(router);
// 初始化mixins
mixins.initMixins(Vue, router);
// 定义$Router属性
Object.defineProperty(Vue.prototype, "$Router", {
get: function() {
var routerInstance = router;
Object.defineProperty(this, "$Router", {
value: routerInstance,
writable: false,
configurable: false,
enumerable: false
});
Object.seal(routerInstance);
return routerInstance;
}
});
// 定义$Route属性
Object.defineProperty(Vue.prototype, "$Route", {
get: function() {
return navjump.createRoute(router);
}
});
// 定义$AppReady属性
Object.defineProperty(Vue.prototype, "$AppReady", {
get: function() {
if (router.options.platform === "h5") {
return Promise.resolve();
}
return appReadyPromise;
},
set: function(val) {
if (val === true) {
resolveAppReady();
}
}
});
}
};
// 定义currentRoute只读属性
utils.def(router, "currentRoute", function() {
return navjump.createRoute(router);
});
// 注册默认守卫
router.beforeEach(function(to, from, next) {
return next();
});
router.afterEach(function() {});
return router;
}
exports.createRouter = createRouter;
/**
* 挂载路由到Vue实例
* @param {Vue} app - Vue实例
* @param {Router} router - 路由器实例
* @param {string} el - 挂载元素
*/
function RouterMount(app, router, el) {
if (el === void 0) el = "#app";
if (utils.getDataType(router.mount) !== "[object Array]") {
throw new Error("挂载路由失败router.app 应该为数组类型。当前类型:" +
typeof router.mount);
}
router.mount.push({
app: app,
el: el
});
// H5平台特殊处理
if (router.options.platform === "h5") {
var vueRouter = router.$route;
vueRouter.replace({
path: vueRouter.currentRoute.fullPath
});
}
}
exports.RouterMount = RouterMount;
var appReadyPromise = new Promise(function(resolve) {
resolveAppReady = resolve;
});
var resolveAppReady;
},
// ==================== 更多模块... ====================
// 由于文件过大,以下省略其他模块
// 完整模块列表见 chunk-vendors.4d47960d.ANALYSIS.md
}
]);
// ==================== 说明 ====================
/**
* 此文件包含以下主要库
*
* 1. uni-simple-router (路由库)
* - 模块 607, 366, 963, 890, 845, 169, 789, etc.
* - 完整的路由管理功能
* - 页面导航守卫生命周期
*
* 2. 加密库
* - 模块 0116 (HMAC)
* - 模块 0168 (Cipher)
* - 模块 5f79 (Buffer)
* - 模块 1177 (MD5)
* - 模块 2d81 (RMD160)
* - 模块 25a4 (SHA)
*
* 3. 核心Polyfills
* - 模块 00c2 (indexOf)
* - 模块 00ca (getOwnPropertyNames)
* - 其他Object/Array方法
*
* 4. 工具函数
* - 对象操作
* - 数组操作
* - 类型判断
* - 继承工具
*
* 总共包含约200+个模块
* 完整列表和详细说明见分析文档
*/