// Immediately invoked function expression (IIFE) to create a global context
!function(){
  try {
    // Attempt to assign global 'this' to variable 'a'
    var a = Function("return this")();

    // Check if 'Math' exists in global context, if not, add standard global objects/functions
    if (a && !a.Math) {
      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
      });
      // If Reflect is defined, assign it to the global context
      if (typeof Reflect !== 'undefined') {
        a.Reflect = Reflect;
      }
    }
  } catch (e) {}
}();

// Start of webpack runtime logic
(function(modules) {
  // JSONP callback for chunk loading
  function webpackJsonpCallback(data) {
    var chunkIds = data[0];          // Chunk IDs
    var moreModules = data[1];       // Modules to be added
    var executeModules = data[2];    // Modules to execute

    // Resolves for loaded chunks
    var moduleId, chunkId, i = 0, resolves = [];

    // Mark the chunk as loaded and resolve any promises
    for (; i < chunkIds.length; i++) {
      chunkId = chunkIds[i];
      if (Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {
        resolves.push(installedChunks[chunkId][0]);
      }
      installedChunks[chunkId] = 0;
    }

    // Add new modules to the module cache
    for (moduleId in moreModules) {
      if (Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
        modules[moduleId] = moreModules[moduleId];
      }
    }

    // Call the parent JSONP callback if exists
    if (parentJsonpFunction) parentJsonpFunction(data);

    // Execute deferred modules after resolving
    while (resolves.length) {
      resolves.shift()();
    }

    // Add any entry modules to deferred list for later execution
    deferredModules.push.apply(deferredModules, executeModules || []);

    // Check if deferred modules can be executed now
    return checkDeferredModules();
  };

  // Check if deferred modules can now be executed
  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;
  }

  // Module cache to store loaded modules
  var installedModules = {};

  // Object to track loaded CSS chunks
  var installedCssChunks = {
    "common/runtime": 0
  };

  // Object to track loaded and loading chunks
  var installedChunks = {
    "common/runtime": 0
  };

  // Array for deferred modules
  var deferredModules = [];

  // Function to generate script path for a chunk
  function jsonpScriptSrc(chunkId) {
    return __webpack_require__.p + "" + chunkId + ".js";
  }

  // The webpack 'require' function for loading modules
  function __webpack_require__(moduleId) {
    // Check if the module is already in cache
    if (installedModules[moduleId]) {
      return installedModules[moduleId].exports;
    }

    // Create a new module and store it in the cache
    var module = installedModules[moduleId] = {
      i: moduleId,
      l: false,
      exports: {}
    };

    // Execute the module function
    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

    // Mark the module as loaded
    module.l = true;

    // Return the module's exports
    return module.exports;
  }

  // Function for chunk loading, ensures chunks are loaded in the right order
  __webpack_require__.e = function requireEnsure(chunkId) {
    var promises = [];

    // CSS loading for mini-css-extract-plugin
    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
    };

    // Check and load CSS chunk if not already loaded
    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 = "" + (cssChunks[chunkId] || chunkId) + ".wxss";
        var fullhref = __webpack_require__.p + href;

        // Check if the CSS is already in the document
        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();
        }

        // If not found, create a new link tag to load the CSS
        var linkTag = document.createElement("link");
        linkTag.rel = "stylesheet";
        linkTag.type = "text/css";
        linkTag.onload = resolve;
        linkTag.onerror = function(event) {
          var request = event && event.target && event.target.src || fullhref;
          var err = new Error("Loading CSS chunk " + chunkId + " failed.\n(" + request + ")");
          err.code = "CSS_CHUNK_LOAD_FAILED";
          err.request = request;
          delete installedCssChunks[chunkId];
          linkTag.parentNode.removeChild(linkTag);
          reject(err);
        };
        linkTag.href = fullhref;

        // Append the new link tag to the head
        var head = document.getElementsByTagName("head")[0];
        head.appendChild(linkTag);
      }).then(function() {
        installedCssChunks[chunkId] = 0;
      }));
    }

    // JavaScript chunk loading
    var installedChunkData = installedChunks[chunkId];
    if (installedChunkData !== 0) {
      if (installedChunkData) {
        promises.push(installedChunkData[2]);
      } else {
        var promise = new Promise(function(resolve, reject) {
          installedChunkData = installedChunks[chunkId] = [resolve, reject];
        });
        promises.push(installedChunkData[2] = promise);

        // Start chunk loading by creating a script tag
        var script = document.createElement('script');
        var onScriptComplete;

        script.charset = 'utf-8';
        script.timeout = 120;

        if (__webpack_require__.nc) {
          script.setAttribute("nonce", __webpack_require__.nc);
        }

        script.src = jsonpScriptSrc(chunkId);

        // Handle script loading errors
        var error = new Error();
        onScriptComplete = function(event) {
          script.onerror = script.onload = null;
          clearTimeout(timeout);
          var chunk = installedChunks[chunkId];
          if (chunk !== 0) {
            if (chunk) {
              var errorType = event && (event.type === 'load' ? 'missing' : event.type);
              var realSrc = event && event.target && event.target.src;
              error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
              error.name = 'ChunkLoadError';
              error.type = errorType;
              error.request = realSrc;
              chunk[1](error);
            }
            installedChunks[chunkId] = undefined;
          }
        };

        // Set timeout to reject the script loading if it takes too long
        var timeout = setTimeout(function() {
          onScriptComplete({ type: 'timeout', target: script });
        }, 120000);

        script.onerror = script.onload = onScriptComplete;
        document.head.appendChild(script);
      }
    }
    return Promise.all(promises);
  };

  // Expose modules and cache
  __webpack_require__.m = modules;
  __webpack_require__.c = installedModules;

  // Define getter functions for harmony exports
  __webpack_require__.d = function(exports, name, getter) {
    if (!__webpack_require__.o(exports, name)) {
      Object.defineProperty(exports, name, { enumerable: true, get: getter });
    }
  };

  // Define __esModule on exports
  __webpack_require__.r = function(exports) {
    if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
      Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
    }
    Object.defineProperty(exports, '__esModule', { value: true });
  };

  // Handle module namespace for compatibility
  __webpack_require__.t = function(value, mode) {
    if (mode & 1) value = __webpack_require__(value);
    if (mode & 8) return value;
    if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
    var ns = Object.create(null);
    __webpack_require__.r(ns);
    Object.defineProperty(ns, 'default', { enumerable: true, value: value });
    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;
  };

  // Get default export for compatibility with non-harmony modules
  __webpack_require__.n = function(module) {
    var getter = module && module.__esModule ?
        function getDefault() { return module['default']; } :
        function getModuleExports() { return module; };
    __webpack_require__.d(getter, 'a', getter);
    return getter;
  };

  // Object.prototype.hasOwnProperty.call
  __webpack_require__.o = function(object, property) {
    return Object.prototype.hasOwnProperty.call(object, property);
  };

  // Public path for assets
  __webpack_require__.p = "/";

  // Error handling for async loading
  __webpack_require__.oe = function(err) {
    console.error(err);
    throw err;
  };

  // JSONP array for async chunk loading
  var jsonpArray = global["webpackJsonp"] = global["webpackJsonp"] || [];
  var oldJsonpFunction = jsonpArray.push.bind(jsonpArray);
  jsonpArray.push = webpackJsonpCallback;
  jsonpArray = jsonpArray.slice();
  for (var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);
  var parentJsonpFunction = oldJsonpFunction;

  // Run deferred modules after chunk loading
  checkDeferredModules();
})([]);
//# sourceMappingURL=../../.sourcemap/mp-weixin/common/runtime.js.map