/*! 这段代码用于处理模块加载和全局对象的兼容性。 */

(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