// ============================================
// 反编译后的可读版本
// 原文件: 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+个模块
 * 完整列表和详细说明见分析文档
 */