text: import { isArray, isPromise, isFunction, isPlainObject, hasOwn, isString } from '@vue/shared';
  
  const EPS = 1e-4;
  const BASE_DEVICE_WIDTH = 750;
  let isIOS = false;
  let deviceWidth = 0;
  let deviceDPR = 0;
  function checkDeviceWidth() {
      const { platform, pixelRatio, windowWidth } = swan.getSystemInfoSync();
      deviceWidth = windowWidth;
      deviceDPR = pixelRatio;
      isIOS = platform === 'ios';
  }
  function upx2px(number, newDeviceWidth) {
      if (deviceWidth === 0) {
          checkDeviceWidth();
      }
      number = Number(number);
      if (number === 0) {
          return 0;
      }
      let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth);
      if (result < 0) {
          result = -result;
      }
      result = Math.floor(result + EPS);
      if (result === 0) {
          if (deviceDPR === 1 || !isIOS) {
              result = 1;
          }
          else {
              result = 0.5;
          }
      }
      return number < 0 ? -result : result;
  }
  
  var HOOKS;
  (function (HOOKS) {
      HOOKS["INVOKE"] = "invoke";
      HOOKS["SUCCESS"] = "success";
      HOOKS["FAIL"] = "fail";
      HOOKS["COMPLETE"] = "complete";
      HOOKS["RETURN_VALUE"] = "returnValue";
  })(HOOKS || (HOOKS = {}));
  const globalInterceptors = {};
  const scopedInterceptors = {};
  function wrapperHook(hook) {
      return function (data) {
          return hook(data) || data;
      };
  }
  function queue(hooks, data) {
      let promise = false;
      for (let i = 0; i < hooks.length; i++) {
          const hook = hooks[i];
          if (promise) {
              promise = Promise.resolve(wrapperHook(hook));
          }
          else {
              const res = hook(data);
              if (isPromise(res)) {
                  promise = Promise.resolve(res);
              }
              if (res === false) {
                  return {
                      then() { },
                      catch() { }
                  };
              }
          }
      }
      return (promise || {
          then(callback) {
              return callback(data);
          },
          catch() { }
      });
  }
  function wrapperOptions(interceptors, options = {}) {
      [HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => {
          const hooks = interceptors[name];
          if (!isArray(hooks)) {
              return;
          }
          const oldCallback = options[name];
          options[name] = function callbackInterceptor(res) {
              queue(hooks, res).then((res) => {
                  return (isFunction(oldCallback) && oldCallback(res)) || res;
              });
          };
      });
      return options;
  }
  function wrapperReturnValue(method, returnValue) {
      const returnValueHooks = [];
      if (isArray(globalInterceptors.returnValue)) {
          returnValueHooks.push(...globalInterceptors.returnValue);
      }
      const interceptor = scopedInterceptors[method];
      if (interceptor && isArray(interceptor.returnValue)) {
          returnValueHooks.push(...interceptor.returnValue);
      }
      returnValueHooks.forEach(hook => {
          returnValue = hook(returnValue) || returnValue;
      });
      return returnValue;
  }
  function getApiInterceptorHooks(method) {
      const interceptor = Object.create(null);
      Object.keys(globalInterceptors).forEach(hook => {
          if (hook !== 'returnValue') {
              interceptor[hook] = globalInterceptors[hook].slice();
          }
      });
      const scopedInterceptor = scopedInterceptors[method];
      if (scopedInterceptor) {
          Object.keys(scopedInterceptor).forEach(hook => {
              if (hook !== 'returnValue') {
                  interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
              }
          });
      }
      return interceptor;
  }
  function invokeApi(method, api, options, ...params) {
      const interceptor = getApiInterceptorHooks(method);
      if (interceptor && Object.keys(interceptor).length) {
          if (isArray(interceptor.invoke)) {
              const res = queue(interceptor.invoke, options);
              return res.then(options => {
                  return api(wrapperOptions(interceptor, options), ...params);
              });
          }
          else {
              return api(wrapperOptions(interceptor, options), ...params);
          }
      }
      return api(options, ...params);
  }
  
  function mergeInterceptorHook(interceptors, interceptor) {
      Object.keys(interceptor).forEach(hook => {
          if (isFunction(interceptor[hook])) {
              interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]);
          }
      });
  }
  function removeInterceptorHook(interceptors, interceptor) {
      if (!interceptors || !interceptor) {
          return;
      }
      Object.keys(interceptor).forEach(hook => {
          if (isFunction(interceptor[hook])) {
              removeHook(interceptors[hook], interceptor[hook]);
          }
      });
  }
  function mergeHook(parentVal, childVal) {
      const res = childVal
          ? parentVal
              ? parentVal.concat(childVal)
              : isArray(childVal)
                  ? childVal
                  : [childVal]
          : parentVal;
      return res ? dedupeHooks(res) : res;
  }
  function dedupeHooks(hooks) {
      const res = [];
      for (let i = 0; i < hooks.length; i++) {
          if (res.indexOf(hooks[i]) === -1) {
              res.push(hooks[i]);
          }
      }
      return res;
  }
  function removeHook(hooks, hook) {
      if (!hooks) {
          return;
      }
      const index = hooks.indexOf(hook);
      if (index !== -1) {
          hooks.splice(index, 1);
      }
  }
  function addInterceptor(method, interceptor) {
      if (typeof method === 'string' && isPlainObject(interceptor)) {
          mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
      }
      else if (isPlainObject(method)) {
          mergeInterceptorHook(globalInterceptors, method);
      }
  }
  function removeInterceptor(method, interceptor) {
      if (typeof method === 'string') {
          if (isPlainObject(interceptor)) {
              removeInterceptorHook(scopedInterceptors[method], interceptor);
          }
          else {
              delete scopedInterceptors[method];
          }
      }
      else if (isPlainObject(method)) {
          removeInterceptorHook(globalInterceptors, method);
      }
  }
  
  const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/;
  const CONTEXT_API_RE = /^create|Manager$/;
  // Context例外情况
  const CONTEXT_API_RE_EXC = ['createBLEConnection'];
  // 同步例外情况
  const ASYNC_API = ['createBLEConnection'];
  const CALLBACK_API_RE = /^on|^off/;
  function isContextApi(name) {
      return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1;
  }
  function isSyncApi(name) {
      return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1;
  }
  function isCallbackApi(name) {
      return CALLBACK_API_RE.test(name) && name !== 'onPush';
  }
  function handlePromise(promise) {
      if (!__UNI_PROMISE_API__) {
          return promise;
      }
      return promise
          .then(data => {
          return [null, data];
      })
          .catch(err => [err]);
  }
  function shouldPromise(name) {
      if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) {
          return false;
      }
      return true;
  }
  /* eslint-disable no-extend-native */
  if (!Promise.prototype.finally) {
      Promise.prototype.finally = function (onfinally) {
          const promise = this.constructor;
          return this.then(value => promise.resolve(onfinally && onfinally()).then(() => value), reason => promise.resolve(onfinally && onfinally()).then(() => {
              throw reason;
          }));
      };
  }
  function promisify(name, api) {
      if (!shouldPromise(name)) {
          return api;
      }
      if (!isFunction(api)) {
          return api;
      }
      return function promiseApi(options = {}, ...params) {
          if (isFunction(options.success) ||
              isFunction(options.fail) ||
              isFunction(options.complete)) {
              return wrapperReturnValue(name, invokeApi(name, api, options, ...params));
          }
          return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => {
              invokeApi(name, api, Object.assign({}, options, {
                  success: resolve,
                  fail: reject
              }), ...params);
          })));
      };
  }
  
  const CALLBACKS = ['success', 'fail', 'cancel', 'complete'];
  function initWrapper(protocols) {
      function processCallback(methodName, method, returnValue) {
          return function (res) {
              return method(processReturnValue(methodName, res, returnValue));
          };
      }
      function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) {
          if (isPlainObject(fromArgs)) {
              // 一般 api 的参数解析
              const toArgs = (keepFromArgs === true ? fromArgs : {}); // returnValue 为 false 时，说明是格式化返回值，直接在返回值对象上修改赋值
              if (isFunction(argsOption)) {
                  argsOption = argsOption(fromArgs, toArgs) || {};
              }
              for (const key in fromArgs) {
                  if (hasOwn(argsOption, key)) {
                      let keyOption = argsOption[key];
                      if (isFunction(keyOption)) {
                          keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
                      }
                      if (!keyOption) {
                          // 不支持的参数
                          console.warn(`百度小程序 ${methodName} 暂不支持 ${key}`);
                      }
                      else if (isString(keyOption)) {
                          // 重写参数 key
                          toArgs[keyOption] = fromArgs[key];
                      }
                      else if (isPlainObject(keyOption)) {
                          // {name:newName,value:value}可重新指定参数 key:value
                          toArgs[keyOption.name ? keyOption.name : key] = keyOption.value;
                      }
                  }
                  else if (CALLBACKS.indexOf(key) !== -1) {
                      const callback = fromArgs[key];
                      if (isFunction(callback)) {
                          toArgs[key] = processCallback(methodName, callback, returnValue);
                      }
                  }
                  else {
                      if (!keepFromArgs && !hasOwn(toArgs, key)) {
                          toArgs[key] = fromArgs[key];
                      }
                  }
              }
              return toArgs;
          }
          else if (isFunction(fromArgs)) {
              fromArgs = processCallback(methodName, fromArgs, returnValue);
          }
          return fromArgs;
      }
      function processReturnValue(methodName, res, returnValue, keepReturnValue = false) {
          if (isFunction(protocols.returnValue)) {
              // 处理通用 returnValue
              res = protocols.returnValue(methodName, res);
          }
          return processArgs(methodName, res, returnValue, {}, keepReturnValue);
      }
      return function wrapper(methodName, method) {
          if (!hasOwn(protocols, methodName)) {
              return method;
          }
          const protocol = protocols[methodName];
          if (!protocol) {
              // 暂不支持的 api
              return function () {
                  console.error(`百度小程序 暂不支持${methodName}`);
              };
          }
          return function (arg1, arg2) {
              // 目前 api 最多两个参数
              let options = protocol;
              if (isFunction(protocol)) {
                  options = protocol(arg1);
              }
              arg1 = processArgs(methodName, arg1, options.args, options.returnValue);
              const args = [arg1];
              if (typeof arg2 !== 'undefined') {
                  args.push(arg2);
              }
              const returnValue = swan[options.name || methodName].apply(swan, args);
              if (isSyncApi(methodName)) {
                  // 同步 api
                  return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName));
              }
              return returnValue;
          };
      };
  }
  
  const baseApis = { upx2px, addInterceptor, removeInterceptor };
  function initUni(api, protocols) {
      const wrapper = initWrapper(protocols);
      const UniProxyHandlers = {
          get(target, key) {
              if (hasOwn(target, key)) {
                  return target[key];
              }
              if (hasOwn(api, key)) {
                  return promisify(key, api[key]);
              }
              if (hasOwn(baseApis, key)) {
                  return promisify(key, baseApis[key]);
              }
              // event-api
              // provider-api?
              return promisify(key, wrapper(key, swan[key]));
          }
      };
      return new Proxy({}, UniProxyHandlers);
  }
  
  function initGetProvider(providers) {
      return function getProvider({ service, success, fail, complete }) {
          let res;
          if (providers[service]) {
              res = {
                  errMsg: 'getProvider:ok',
                  service,
                  provider: providers[service]
              };
              isFunction(success) && success(res);
          }
          else {
              res = {
                  errMsg: 'getProvider:fail:服务[' + service + ']不存在'
              };
              isFunction(fail) && fail(res);
          }
          isFunction(complete) && complete(res);
      };
  }
  
  const previewImage = {
      args(fromArgs, toArgs) {
          let currentIndex = parseInt(fromArgs.current);
          if (isNaN(currentIndex)) {
              return;
          }
          const urls = fromArgs.urls;
          if (!isArray(urls)) {
              return;
          }
          const len = urls.length;
          if (!len) {
              return;
          }
          if (currentIndex < 0) {
              currentIndex = 0;
          }
          else if (currentIndex >= len) {
              currentIndex = len - 1;
          }
          if (currentIndex > 0) {
              toArgs.current = urls[currentIndex];
              toArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
          }
          else {
              toArgs.current = urls[0];
          }
          return {
              indicator: false,
              loop: false
          };
      }
  };
  function addSafeAreaInsets(fromRes, toRes) {
      if (fromRes.safeArea) {
          const safeArea = fromRes.safeArea;
          toRes.safeAreaInsets = {
              top: safeArea.top,
              left: safeArea.left,
              right: fromRes.windowWidth - safeArea.right,
              bottom: fromRes.windowHeight - safeArea.bottom
          };
      }
  }
  const getSystemInfo = {
      returnValue: addSafeAreaInsets
  };
  const getSystemInfoSync = getSystemInfo;
  
  const getProvider = initGetProvider({
      oauth: ['baidu'],
      share: ['baidu'],
      payment: ['baidu'],
      push: ['baidu']
  });
  function requestPayment(params) {
      let parseError = false;
      if (typeof params.orderInfo === 'string') {
          try {
              params.orderInfo = JSON.parse(params.orderInfo);
          }
          catch (e) {
              parseError = true;
          }
      }
      if (parseError) {
          params.fail &&
              params.fail({
                  errMsg: 'requestPayment:fail: 参数 orderInfo 数据结构不正确，参考：https://uniapp.dcloud.io/api/plugins/payment?id=orderinfo'
              });
      }
      else {
          swan.requestPolymerPayment(params);
      }
  }
  
  var shims = /*#__PURE__*/Object.freeze({
    __proto__: null,
    getProvider: getProvider,
    requestPayment: requestPayment
  });
  
  function createTodoMethod(contextName, methodName) {
      return function unsupported() {
          console.error(`百度小程序 ${contextName}暂不支持${methodName}`);
      };
  }
  const request = {
      args() {
          // TODO
          // data 不支持 ArrayBuffer
          // method 不支持 TRACE, CONNECT
          return {
              method: 'method',
              dataType(type) {
                  return {
                      name: 'dataType',
                      value: type === 'json' ? type : 'string'
                  };
              }
          };
      }
  };
  const connectSocket = {
      args: {
          method: false
      }
  };
  const getRecorderManager = {
      returnValue(fromRes, toRes) {
          toRes.onFrameRecorded = createTodoMethod('RecorderManager', 'onFrameRecorded');
      }
  };
  const getBackgroundAudioManager = {
      returnValue(fromRes, toRes) {
          toRes.onPrev = createTodoMethod('BackgroundAudioManager', 'onPrev');
          toRes.onNext = createTodoMethod('BackgroundAudioManager', 'onNext');
      }
  };
  const scanCode = {
      args: {
          onlyFromCamera: false,
          scanType: false
      }
  };
  const navigateToMiniProgram = {
      name: 'navigateToSmartProgram',
      args: {
          appId: 'appKey',
          envVersion: false
      }
  };
  const navigateBackMiniProgram = {
      name: 'navigateBackSmartProgram'
  };
  const showShareMenu = {
      name: 'openShare'
  };
  const getAccountInfoSync = {
      name: 'getEnvInfoSync',
      returnValue(fromRes, toRes) {
          toRes.miniProgram = {
              appId: fromRes.appKey
          };
          toRes.plugin = {
              appId: '',
              version: fromRes.sdkVersion
          };
      }
  };
  
  var protocols = /*#__PURE__*/Object.freeze({
    __proto__: null,
    request: request,
    connectSocket: connectSocket,
    getRecorderManager: getRecorderManager,
    getBackgroundAudioManager: getBackgroundAudioManager,
    scanCode: scanCode,
    navigateToMiniProgram: navigateToMiniProgram,
    navigateBackMiniProgram: navigateBackMiniProgram,
    showShareMenu: showShareMenu,
    getAccountInfoSync: getAccountInfoSync,
    previewImage: previewImage,
    getSystemInfo: getSystemInfo,
    getSystemInfoSync: getSystemInfoSync
  });
  
  var index = initUni(shims, protocols);
  
  export default index;
  