|
|
/*! 这段代码用于处理模块加载和全局对象的兼容性。 */
|
|
|
|
|
|
(function() {
|
|
|
try {
|
|
|
// 尝试获取全局对象 (通常是浏览器环境中的 window 或 Node.js 环境中的 global)
|
|
|
var a = Function("return this")();
|
|
|
|
|
|
// 如果获取到了全局对象并且该对象没有 Math 属性
|
|
|
if (a && !a.Math) {
|
|
|
// 将全局对象（a）补充上常见的全局对象和方法
|
|
|
Object.assign(a, {
|
|
|
isFinite: isFinite,
|
|
|
// 处理数值是否有限的方法
|
|
|
Array: Array,
|
|
|
// 数组构造函数
|
|
|
Date: Date,
|
|
|
// 日期构造函数
|
|
|
Error: Error,
|
|
|
// 错误构造函数
|
|
|
Function: Function,
|
|
|
// 函数构造函数
|
|
|
Math: Math,
|
|
|
// 数学对象
|
|
|
Object: Object,
|
|
|
// 对象构造函数
|
|
|
RegExp: RegExp,
|
|
|
// 正则表达式构造函数
|
|
|
String: String,
|
|
|
// 字符串构造函数
|
|
|
TypeError: TypeError,
|
|
|
// 类型错误构造函数
|
|
|
setTimeout: setTimeout,
|
|
|
// 设置定时器方法
|
|
|
clearTimeout: clearTimeout,
|
|
|
// 清除定时器方法
|
|
|
setInterval: setInterval,
|
|
|
// 设置间隔定时器方法
|
|
|
clearInterval: clearInterval
|
|
|
// 清除间隔定时器方法
|
|
|
});
|
|
|
|
|
|
// 如果环境中有 Reflect 对象（通常是 ECMAScript 6 引入的），则将其添加到全局对象中
|
|
|
if (typeof Reflect !== "undefined") {
|
|
|
a.Reflect = Reflect;
|
|
|
}
|
|
|
}
|
|
|
} catch (a) {
|
|
|
// 如果发生异常，捕获错误并不做处理
|
|
|
}
|
|
|
})();
|
|
|
|
|
|
/* 以下代码是 Webpack 的代码片段，用于动态加载和处理模块（chunk）。 */
|
|
|
|
|
|
// webpackBootstrap 开始
|
|
|
(function(modules) {
|
|
|
// 安装 JSONP 回调用于 chunk 加载
|
|
|
function webpackJsonpCallback(data) {
|
|
|
var chunkIds = data[0]; // 当前 chunk 的 ID
|
|
|
var moreModules = data[1]; // 当前 chunk 中的模块
|
|
|
var executeModules = data[2]; // 要执行的模块
|
|
|
|
|
|
// 将 "moreModules" 添加到模块对象中，并标记所有 "chunkIds" 为已加载，并触发回调
|
|
|
var moduleId, chunkId, i = 0, resolves = [];
|
|
|
for (; i < chunkIds.length; i++) {
|
|
|
chunkId = chunkIds[i];
|
|
|
// 如果该 chunk 已加载，则将其回调加入 resolves 队列
|
|
|
if (Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {
|
|
|
resolves.push(installedChunks[chunkId][0]);
|
|
|
}
|
|
|
installedChunks[chunkId] = 0;
|
|
|
// 标记当前 chunk 已加载
|
|
|
}
|
|
|
|
|
|
// 将模块添加到模块对象中
|
|
|
for (moduleId in moreModules) {
|
|
|
if (Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
|
|
|
modules[moduleId] = moreModules[moduleId];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果父级 JSONP 函数存在，调用它（用于处理嵌套的 chunk 加载）
|
|
|
if (parentJsonpFunction) parentJsonpFunction(data);
|
|
|
|
|
|
// 执行已解决的模块（即已加载的模块）
|
|
|
while (resolves.length) {
|
|
|
resolves.shift()();
|
|
|
}
|
|
|
|
|
|
// 将从当前 chunk 加载的条目模块推入延迟执行列表
|
|
|
deferredModules.push.apply(deferredModules, executeModules || []);
|
|
|
|
|
|
// 当所有 chunk 准备好时，运行延迟的模块
|
|
|
return checkDeferredModules();
|
|
|
}
|
|
|
|
|
|
// 检查并执行延迟加载的模块
|
|
|
function checkDeferredModules() {
|
|
|
var result;
|
|
|
// 遍历所有延迟的模块
|
|
|
for (var i = 0; i < deferredModules.length; i++) {
|
|
|
var deferredModule = deferredModules[i];
|
|
|
var fulfilled = true;
|
|
|
// 检查所有依赖项是否已加载
|
|
|
for (var j = 1; j < deferredModule.length; j++) {
|
|
|
var depId = deferredModule[j];
|
|
|
if (installedChunks[depId] !== 0) fulfilled = false;
|
|
|
}
|
|
|
// 如果所有依赖已满足，则加载该模块
|
|
|
if (fulfilled) {
|
|
|
deferredModules.splice(i--, 1); // 从延迟模块列表中移除该模块
|
|
|
result = __webpack_require__(__webpack_require__.s = deferredModule[0]);
|
|
|
}
|
|
|
}
|
|
|
/******/
|
|
|
/******/ return result;
|
|
|
/******/ }
|
|
|
/******/
|
|
|
/******/ /// 模块缓存对象，用于存储已加载的模块。
|
|
|
// 这样一来，当模块被加载一次后，后续对该模块的请求将直接返回缓存中的模块，避免重复加载。
|
|
|
var installedModules = {};
|
|
|
|
|
|
/*
|
|
|
* 存储已加载的 CSS chunk（代码块）对象。
|
|
|
* 在这里，"common/runtime" 是一个 CSS chunk 的标识符，0 表示它已经被加载。
|
|
|
* Webpack 会根据配置分离不同的 chunk，CSS 通常会单独打包。
|
|
|
*/
|
|
|
var installedCssChunks = {
|
|
|
"common/runtime": 0
|
|
|
};
|
|
|
|
|
|
// 存储已加载和正在加载的 JavaScript chunk（代码块）对象。
|
|
|
// undefined = chunk 尚未加载，null = chunk 已预加载或预取，
|
|
|
// Promise = chunk 正在加载，0 = chunk 已加载。
|
|
|
// "common/runtime" 初始值为 0，表示该 chunk 已加载。
|
|
|
var installedChunks = {
|
|
|
"common/runtime": 0
|
|
|
};
|
|
|
|
|
|
// 存储延迟加载的模块。当模块需要异步加载时，它们会被推入这个队列，待所有依赖满足后执行。
|
|
|
var deferredModules = [];
|
|
|
|
|
|
/*
|
|
|
* 获取 chunk 脚本的路径，WebPack 会根据配置动态生成加载文件的路径。
|
|
|
* chunkId 是当前加载的 chunk 的 ID，通常是 chunk 名称。
|
|
|
* `__webpack_require__.p` 是 Webpack 配置的公共路径，通常是资源文件存放的路径。
|
|
|
* 例如，`chunkId` 可能是 "1"，路径可能是 `/static/js/1.js`。
|
|
|
*/
|
|
|
function jsonpScriptSrc(chunkId) {
|
|
|
return __webpack_require__.p + "" + chunkId + ".js";
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* `__webpack_require__` 是 Webpack 打包后的模块加载函数，类似于 CommonJS 的 require。
|
|
|
* 它用来加载模块并返回模块的 `exports`。
|
|
|
* 参数 `moduleId` 是模块的 ID，通常是模块的文件名或 chunk ID。
|
|
|
*/
|
|
|
function __webpack_require__(moduleId) {
|
|
|
// 1. 检查模块是否已经在缓存中（即是否已加载过）
|
|
|
if(installedModules[moduleId]) {
|
|
|
// 如果模块已经加载过，则直接返回缓存中的模块的 exports（导出的对象）
|
|
|
return installedModules[moduleId].exports;
|
|
|
}
|
|
|
|
|
|
// 2. 如果模块尚未加载，创建一个新的模块并放入缓存
|
|
|
var module = installedModules[moduleId] = {
|
|
|
i: moduleId, // 模块 ID
|
|
|
l: false, // 模块加载标记，表示模块尚未加载
|
|
|
exports: {} // 模块的导出对象，模块的功能和数据会挂载到这个对象上
|
|
|
};
|
|
|
|
|
|
// 3. 执行该模块的代码（将模块的功能添加到 exports 中）
|
|
|
// `modules[moduleId]` 存储了模块的定义（即模块代码），`call` 用于调用该模块的函数并传入需要的参数。
|
|
|
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
|
|
// 4. 标记模块为已加载
|
|
|
module.l = true;
|
|
|
|
|
|
// 5. 返回模块的 exports 对象，即模块对外暴露的内容
|
|
|
return module.exports;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* `__webpack_require__.e` 是 Webpack 为动态加载模块提供的一个方法。
|
|
|
* 它允许异步加载额外的 chunks（代码块），例如通过 `import()` 动态加载模块。
|
|
|
* 参数 `chunkId` 是要加载的 chunk 的 ID，通常是一个数字或字符串。
|
|
|
* Webpack 会根据 `chunkId` 加载相应的 JavaScript 文件，处理异步依赖关系。
|
|
|
*/
|
|
|
__webpack_require__.e = function requireEnsure(chunkId) {
|
|
|
var promises = []; // 存储等待加载的 Promise 对象
|
|
|
|
|
|
/******/
|
|
|
/******/
|
|
|
/******/ // mini-css-extract-plugin CSS loading
|
|
|
/******/ var cssChunks = {"components/uni-phone/index":1,"pages/common/Navbar/navbar":1,"components/uni-nav-bar/uni-nav-bar":1,"components/uni-piker/index":1,"components/uni-popup/index":1,"node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item":1,"uni_modules/uni-list/components/uni-list-item/uni-list-item":1,"uni_modules/uni-list/components/uni-list/uni-list":1,"uni_modules/uni-popup/components/uni-popup/uni-popup":1,"components/empty/empty":1,"components/reach-bottom/reach-bottom":1,"pages/common/simple-address/simple-address":1,"node-modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput":1,"uni_modules/uni-easyinput/components/uni-easyinput/uni-easyinput":1,"components/uni-icons/uni-icons":1,"components/uni-status-bar/uni-status-bar":1,"uni_modules/uni-badge/components/uni-badge/uni-badge":1};
|
|
|
/******/ if(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);
|
|
|
/******/ else if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {
|
|
|
/******/ promises.push(installedCssChunks[chunkId] = new Promise(function(resolve, reject) {
|
|
|
/******/ var href = "" + ({"components/uni-phone/index":"components/uni-phone/index","pages/common/Navbar/navbar":"pages/common/Navbar/navbar","components/uni-nav-bar/uni-nav-bar":"components/uni-nav-bar/uni-nav-bar","components/uni-piker/index":"components/uni-piker/index","components/uni-popup/index":"components/uni-popup/index","node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item":"node-modules/@dcloudio/uni-ui/lib/uni-list-item/uni-list-item","uni_modules/uni-list/components/uni-list-item/uni-list-item":"uni_modules/uni-list/components/uni-list-item/uni-list-item","uni_modules/uni-list/components/uni-list/uni-list":"uni_modules/uni-list/components/uni-list/uni-list","uni_modules/uni-popup/components/uni-popup/uni-popup":"uni_modules/uni-popup/components/uni-popup/uni-popup","components/empty/empty":"components/empty/empty","components/reach-bottom/reach-bottom":"components/reach-bottom/reach-bottom","pages/common/simple-address/simple-address":"pages/common/simple-address/simple-address","node-modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput":"node-modules/@dcloudio/uni-ui/lib/uni-easyinput/uni-easyinput","uni_modules/uni-easyinput/components/uni-easyinput/uni-easyinput":"uni_modules/uni-easyinput/components/uni-easyinput/uni-easyinput","components/uni-icons/uni-icons":"components/uni-icons/uni-icons","components/uni-status-bar/uni-status-bar":"components/uni-status-bar/uni-status-bar","uni_modules/uni-badge/components/uni-badge/uni-badge":"uni_modules/uni-badge/components/uni-badge/uni-badge","uni_modules/uni-transition/components/uni-transition/uni-transition":"uni_modules/uni-transition/components/uni-transition/uni-transition"}[chunkId]||chunkId) + ".wxss";
|
|
|
/******/ var fullhref = __webpack_require__.p + href;
|
|
|
/******/ var existingLinkTags = document.getElementsByTagName("link");
|
|
|
/******/ for(var i = 0; i < existingLinkTags.length; i++) {
|
|
|
/******/ var tag = existingLinkTags[i];
|
|
|
/******/ var dataHref = tag.getAttribute("data-href") || tag.getAttribute("href");
|
|
|
/******/ if(tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return resolve();
|
|
|
/******/ }
|
|
|
/******/ // 获取页面中所有已存在的 <style> 标签
|
|
|
var existingStyleTags = document.getElementsByTagName("style");
|
|
|
|
|
|
// 遍历所有的 <style> 标签，检查是否有已加载的相同 CSS 文件。
|
|
|
// 目的是避免重复加载相同的 CSS 文件。
|
|
|
for (var i = 0; i < existingStyleTags.length; i++) {
|
|
|
var tag = existingStyleTags[i];
|
|
|
|
|
|
// 获取 <style> 标签的 data-href 属性，这个属性用来存储该 CSS 文件的路径
|
|
|
var dataHref = tag.getAttribute("data-href");
|
|
|
|
|
|
// 如果该 CSS 文件路径和当前正在加载的路径相同，说明该 CSS 文件已经加载，直接返回 resolve，避免重复加载
|
|
|
if (dataHref === href || dataHref === fullhref) return resolve();
|
|
|
}
|
|
|
|
|
|
// 如果没有找到相同的 <style> 标签，说明需要加载新的 CSS 文件，创建新的 <link> 标签
|
|
|
var linkTag = document.createElement("link");
|
|
|
|
|
|
// 设置 <link> 标签的属性：
|
|
|
// rel 设置为 "stylesheet"，表示该文件是一个样式表
|
|
|
// type 设置为 "text/css"，表示该文件的 MIME 类型为 CSS
|
|
|
linkTag.rel = "stylesheet";
|
|
|
linkTag.type = "text/css";
|
|
|
|
|
|
// 当 CSS 文件加载完成时，调用 resolve，表示加载成功
|
|
|
linkTag.onload = resolve;
|
|
|
|
|
|
// 如果 CSS 文件加载失败，调用 onerror 处理错误
|
|
|
linkTag.onerror = function(event) {
|
|
|
// 获取出错的请求路径（即 CSS 文件路径）
|
|
|
var request = event && event.target && event.target.src || fullhref;
|
|
|
|
|
|
// 创建一个新的 Error 对象，表示加载 CSS 文件失败
|
|
|
var err = new Error("Loading CSS chunk " + chunkId + " failed.\n(" + request + ")");
|
|
|
err.code = "CSS_CHUNK_LOAD_FAILED"; // 给错误添加一个自定义的错误码
|
|
|
err.request = request; // 错误对象中记录出错的请求路径
|
|
|
|
|
|
// 从 installedCssChunks 中删除该 chunkId，表示该 CSS 文件加载失败
|
|
|
delete installedCssChunks[chunkId];
|
|
|
|
|
|
// 移除已创建的 <link> 标签，清理页面
|
|
|
linkTag.parentNode.removeChild(linkTag);
|
|
|
|
|
|
// 调用 reject 传递错误对象，表示加载失败
|
|
|
reject(err);
|
|
|
};
|
|
|
|
|
|
// 设置 <link> 标签的 href 属性，指向需要加载的 CSS 文件的路径
|
|
|
linkTag.href = fullhref;
|
|
|
|
|
|
// 获取页面的 <head> 标签，并将新创建的 <link> 标签添加到页面中
|
|
|
var head = document.getElementsByTagName("head")[0];
|
|
|
head.appendChild(linkTag);
|
|
|
|
|
|
// 在加载 CSS 完成后，标记该 chunkId 的状态为加载完成
|
|
|
}).then(function() {
|
|
|
// 更新 installedCssChunks 对象，表示该 CSS chunk 已经加载完成
|
|
|
installedCssChunks[chunkId] = 0;
|
|
|
}));
|
|
|
|
|
|
/******/ }
|
|
|
/******/
|
|
|
/******/ // JSONP chunk loading for javascript
|
|
|
/******/
|
|
|
/******/ // 从 installedChunks 对象中获取当前 chunkId 对应的安装数据
|
|
|
var installedChunkData = installedChunks[chunkId];
|
|
|
|
|
|
// 如果 installedChunkData 不等于 0，表示该 chunk 尚未加载完成
|
|
|
if (installedChunkData !== 0) { // 0 means "already installed".
|
|
|
|
|
|
// 如果 installedChunkData 存在，说明该 chunk 正在加载中，已经有一个加载的 Promise
|
|
|
if (installedChunkData) {
|
|
|
// 将正在加载的 Promise 添加到 promises 数组中，以便等待加载完成
|
|
|
promises.push(installedChunkData[2]);
|
|
|
} else {
|
|
|
// 如果该 chunk 还没有开始加载，设置一个新的 Promise 来处理 chunk 加载
|
|
|
var promise = new Promise(function(resolve, reject) {
|
|
|
// 将当前 chunkId 的安装数据设置为一个包含 resolve 和 reject 的数组，用来处理 Promise
|
|
|
installedChunkData = installedChunks[chunkId] = [resolve, reject];
|
|
|
});
|
|
|
// 将新创建的 Promise 添加到 promises 数组中
|
|
|
promises.push(installedChunkData[2] = promise);
|
|
|
|
|
|
// 开始加载 chunk 对应的脚本文件
|
|
|
var script = document.createElement('script'); // 创建一个新的 <script> 标签
|
|
|
var onScriptComplete; // 用于处理加载完成或失败的回调函数
|
|
|
|
|
|
script.charset = 'utf-8'; // 设置脚本文件的字符编码为 UTF-8
|
|
|
script.timeout = 120; // 设置加载超时时间为 120 秒
|
|
|
|
|
|
// 如果 __webpack_require__.nc 存在，设置 script 标签的 nonce 属性，增加安全性
|
|
|
if (__webpack_require__.nc) {
|
|
|
script.setAttribute("nonce", __webpack_require__.nc);
|
|
|
}
|
|
|
|
|
|
// 设置 <script> 标签的 src 属性，指向需要加载的 chunk 对应的 JavaScript 文件
|
|
|
script.src = jsonpScriptSrc(chunkId);
|
|
|
|
|
|
// 在 stack unwound 前创建一个错误对象，便于以后获取有用的堆栈信息
|
|
|
var error = new Error();
|
|
|
|
|
|
// 定义当脚本加载完成或失败时的回调函数
|
|
|
onScriptComplete = function (event) {
|
|
|
// 避免内存泄漏，清除 onload 和 onerror 事件处理器
|
|
|
script.onerror = script.onload = null;
|
|
|
// 清除超时定时器
|
|
|
clearTimeout(timeout);
|
|
|
|
|
|
// 获取当前 chunk 的加载状态
|
|
|
var chunk = installedChunks[chunkId];
|
|
|
|
|
|
// 如果 chunk 仍然没有加载完成，表示加载失败
|
|
|
if (chunk !== 0) {
|
|
|
// 如果 chunk 存在，构建一个错误信息，提供详细的错误类型和请求路径
|
|
|
if (chunk) {
|
|
|
var errorType = event && (event.type === 'load' ? 'missing' : event.type); // 判断错误类型是 'load' 还是其他类型
|
|
|
var realSrc = event && event.target && event.target.src; // 获取实际加载失败的文件路径
|
|
|
error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')'; // 构建错误信息
|
|
|
error.name = 'ChunkLoadError'; // 设置错误名称为 ChunkLoadError
|
|
|
error.type = errorType; // 设置错误类型
|
|
|
error.request = realSrc; // 设置错误请求路径
|
|
|
|
|
|
// 调用 reject 函数，表示加载失败并传递错误信息
|
|
|
chunk[1](error);
|
|
|
}
|
|
|
// 将当前 chunk 的加载状态设置为 undefined，表示加载失败
|
|
|
installedChunks[chunkId] = undefined;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// 设置超时定时器，在超过 120 秒后触发错误
|
|
|
var timeout = setTimeout(function(){
|
|
|
onScriptComplete({ type: 'timeout', target: script });
|
|
|
}, 120000); // 设置超时时间为 120 秒
|
|
|
|
|
|
// 将 onload 和 onerror 事件处理器都指向 onScriptComplete 函数
|
|
|
script.onerror = script.onload = onScriptComplete;
|
|
|
|
|
|
// 将创建的 <script> 标签添加到页面的 <head> 中，开始加载该 chunk 的 JavaScript 文件
|
|
|
document.head.appendChild(script);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 返回一个 Promise.all(promises)，等待所有 chunk 加载完成
|
|
|
return Promise.all(promises);
|
|
|
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // 将模块对象（__webpack_modules__）暴露到全局，供其他部分使用
|
|
|
/******/ __webpack_require__.m = modules; // `modules` 是存放所有模块代码的对象
|
|
|
|
|
|
// 将模块缓存（installedModules）暴露到全局，供其他部分使用
|
|
|
/******/ __webpack_require__.c = installedModules; // `installedModules` 存储已加载的模块实例
|
|
|
|
|
|
// 定义一个 getter 函数用于处理 Harmony exports（即 ES6 模块的导出）
|
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
|
/******/ // 如果 exports 对象上没有指定的 `name` 属性，则定义它
|
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); // 使用 Object.defineProperty 来定义属性，确保 getter 是惰性求值的
|
|
|
/******/ }
|
|
|
/******/ };
|
|
|
|
|
|
/******/ // 定义 `__esModule` 属性来标记模块是否为 ES6 模块
|
|
|
/******/ __webpack_require__.r = function(exports) {
|
|
|
/******/ // 如果支持 Symbol，给 exports 对象添加 Symbol.toStringTag 属性，标识该对象是一个模块
|
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
|
/******/ }
|
|
|
/******/ // 给 exports 对象添加 `__esModule` 属性，标识该模块为 ES6 模块
|
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
/******/ };
|
|
|
|
|
|
/******/ // 创建一个伪命名空间对象，用于兼容不同的模块类型
|
|
|
/******/ __webpack_require__.t = function(value, mode) {
|
|
|
/******/ // 如果 mode & 1，表示值是模块 ID，需要通过 `__webpack_require__` 加载模块
|
|
|
/******/ if(mode & 1) value = __webpack_require__(value);
|
|
|
/******/ // 如果 mode & 8，直接返回值（已经是命名空间对象）
|
|
|
/******/ if(mode & 8) return value;
|
|
|
/******/ // 如果 mode & 4，且值是一个 ES6 模块，直接返回值
|
|
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
|
|
/******/ // 否则，创建一个新的命名空间对象
|
|
|
/******/ var ns = Object.create(null);
|
|
|
/******/ // 标记该对象为 ES6 模块对象
|
|
|
/******/ __webpack_require__.r(ns);
|
|
|
/******/ // 设置默认导出为 `value`
|
|
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
|
|
|
/******/ // 如果 mode & 2，且值不是字符串，将其所有属性合并到命名空间对象中
|
|
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
|
|
|
/******/ // 返回命名空间对象
|
|
|
/******/ return ns;
|
|
|
/******/ };
|
|
|
|
|
|
/******/ // 兼容旧式模块的默认导出函数
|
|
|
/******/ __webpack_require__.n = function(module) {
|
|
|
/******/ // 如果模块是一个 ES6 模块，返回其默认导出
|
|
|
/******/ var getter = module && module.__esModule ?
|
|
|
/******/ function getDefault() { return module['default']; } :
|
|
|
/******/ // 否则返回模块本身
|
|
|
/******/ function getModuleExports() { return module; };
|
|
|
/******/ // 使用 `__webpack_require__.d` 为 getter 函数添加属性，使其可以被正常访问
|
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
|
/******/ return getter;
|
|
|
/******/ };
|
|
|
|
|
|
/******/ // 检查对象是否有指定的属性（用于检查模块中是否包含某个属性）
|
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
|
|
|
|
/******/ // 设置公共路径（即 Webpack 加载资源的基础路径）
|
|
|
/******/ __webpack_require__.p = "/"; // 资源的公共路径设置为根路径
|
|
|
|
|
|
/******/ // 异步加载错误处理函数，用于捕获和处理加载模块时发生的错误
|
|
|
/******/ __webpack_require__.oe = function(err) { console.error(err); throw err; };
|
|
|
|
|
|
/******/ // 初始化一个全局 JSONP 数组，用于异步模块加载
|
|
|
/******/ var jsonpArray = global["webpackJsonp"] = global["webpackJsonp"] || []; // 获取或初始化一个全局 JSONP 数组
|
|
|
/******/ var oldJsonpFunction = jsonpArray.push.bind(jsonpArray); // 备份当前的 push 方法
|
|
|
/******/ // 自定义 webpackJsonp 回调函数
|
|
|
/******/ jsonpArray.push = webpackJsonpCallback; // 使用 webpackJsonpCallback 作为新的回调
|
|
|
/******/ jsonpArray = jsonpArray.slice(); // 将数组进行截取，确保已有的模块执行回调
|
|
|
/******/ // 执行已经推入的 webpackJsonpCallback 回调
|
|
|
/******/ for(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);
|
|
|
/******/ // 备份并保存旧的 JSONP 回调函数
|
|
|
/******/ var parentJsonpFunction = oldJsonpFunction;
|
|
|
|
|
|
/******/
|
|
|
/******/ // 检查和运行其他模块的延迟加载，等待模块准备就绪
|
|
|
/******/ checkDeferredModules(); // 检查并加载其他推迟的模块
|
|
|
|
|
|
/******/ })
|
|
|
/************************************************************************/
|
|
|
/******/ ([]); // Webpack 打包代码的结尾，表示该部分没有其他代码执行
|
|
|
//# sourceMappingURL=../../.sourcemap/mp-weixin/common/runtime.js.map
|
