@fecp/mobile 1.0.1

package/lib/node_modules/.pnpm/@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+var inBrowser = typeof window !== "undefined";
+function raf(fn) {
+  return inBrowser ? requestAnimationFrame(fn) : -1;
+}
+function cancelRaf(id) {
+  if (inBrowser) {
+    cancelAnimationFrame(id);
+  }
+}
+function doubleRaf(fn) {
+  raf(() => raf(fn));
+}
+var isWindow = (val) => val === window;
+var makeDOMRect = (width2, height2) => ({
+  top: 0,
+  left: 0,
+  right: width2,
+  bottom: height2,
+  width: width2,
+  height: height2
+});
+var useRect = (elementOrRef) => {
+  const element = vue.unref(elementOrRef);
+  if (isWindow(element)) {
+    const width2 = element.innerWidth;
+    const height2 = element.innerHeight;
+    return makeDOMRect(width2, height2);
+  }
+  if (element == null ? void 0 : element.getBoundingClientRect) {
+    return element.getBoundingClientRect();
+  }
+  return makeDOMRect(0, 0);
+};
+function useToggle(defaultValue = false) {
+  const state = vue.ref(defaultValue);
+  const toggle = (value = !state.value) => {
+    state.value = value;
+  };
+  return [state, toggle];
+}
+function useParent(key) {
+  const parent = vue.inject(key, null);
+  if (parent) {
+    const instance = vue.getCurrentInstance();
+    const { link, unlink, internalChildren } = parent;
+    link(instance);
+    vue.onUnmounted(() => unlink(instance));
+    const index = vue.computed(() => internalChildren.indexOf(instance));
+    return {
+      parent,
+      index
+    };
+  }
+  return {
+    parent: null,
+    index: vue.ref(-1)
+  };
+}
+function flattenVNodes(children) {
+  const result = [];
+  const traverse = (children2) => {
+    if (Array.isArray(children2)) {
+      children2.forEach((child) => {
+        var _a;
+        if (vue.isVNode(child)) {
+          result.push(child);
+          if ((_a = child.component) == null ? void 0 : _a.subTree) {
+            result.push(child.component.subTree);
+            traverse(child.component.subTree.children);
+          }
+          if (child.children) {
+            traverse(child.children);
+          }
+        }
+      });
+    }
+  };
+  traverse(children);
+  return result;
+}
+var findVNodeIndex = (vnodes, vnode) => {
+  const index = vnodes.indexOf(vnode);
+  if (index === -1) {
+    return vnodes.findIndex(
+      (item) => vnode.key !== void 0 && vnode.key !== null && item.type === vnode.type && item.key === vnode.key
+    );
+  }
+  return index;
+};
+function sortChildren(parent, publicChildren, internalChildren) {
+  const vnodes = flattenVNodes(parent.subTree.children);
+  internalChildren.sort(
+    (a, b) => findVNodeIndex(vnodes, a.vnode) - findVNodeIndex(vnodes, b.vnode)
+  );
+  const orderedPublicChildren = internalChildren.map((item) => item.proxy);
+  publicChildren.sort((a, b) => {
+    const indexA = orderedPublicChildren.indexOf(a);
+    const indexB = orderedPublicChildren.indexOf(b);
+    return indexA - indexB;
+  });
+}
+function useChildren(key) {
+  const publicChildren = vue.reactive([]);
+  const internalChildren = vue.reactive([]);
+  const parent = vue.getCurrentInstance();
+  const linkChildren = (value) => {
+    const link = (child) => {
+      if (child.proxy) {
+        internalChildren.push(child);
+        publicChildren.push(child.proxy);
+        sortChildren(parent, publicChildren, internalChildren);
+      }
+    };
+    const unlink = (child) => {
+      const index = internalChildren.indexOf(child);
+      publicChildren.splice(index, 1);
+      internalChildren.splice(index, 1);
+    };
+    vue.provide(
+      key,
+      Object.assign(
+        {
+          link,
+          unlink,
+          children: publicChildren,
+          internalChildren
+        },
+        value
+      )
+    );
+  };
+  return {
+    children: publicChildren,
+    linkChildren
+  };
+}
+function onMountedOrActivated(hook) {
+  let mounted;
+  vue.onMounted(() => {
+    hook();
+    vue.nextTick(() => {
+      mounted = true;
+    });
+  });
+  vue.onActivated(() => {
+    if (mounted) {
+      hook();
+    }
+  });
+}
+function useEventListener(type, listener, options = {}) {
+  if (!inBrowser) {
+    return;
+  }
+  const { target = window, passive = false, capture = false } = options;
+  let cleaned = false;
+  let attached;
+  const add = (target2) => {
+    if (cleaned) {
+      return;
+    }
+    const element = vue.unref(target2);
+    if (element && !attached) {
+      element.addEventListener(type, listener, {
+        capture,
+        passive
+      });
+      attached = true;
+    }
+  };
+  const remove = (target2) => {
+    if (cleaned) {
+      return;
+    }
+    const element = vue.unref(target2);
+    if (element && attached) {
+      element.removeEventListener(type, listener, capture);
+      attached = false;
+    }
+  };
+  vue.onUnmounted(() => remove(target));
+  vue.onDeactivated(() => remove(target));
+  onMountedOrActivated(() => add(target));
+  let stopWatch;
+  if (vue.isRef(target)) {
+    stopWatch = vue.watch(target, (val, oldVal) => {
+      remove(oldVal);
+      add(val);
+    });
+  }
+  return () => {
+    stopWatch == null ? void 0 : stopWatch();
+    remove(target);
+    cleaned = true;
+  };
+}
+function useClickAway(target, listener, options = {}) {
+  if (!inBrowser) {
+    return;
+  }
+  const { eventName = "click" } = options;
+  const onClick = (event) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const isClickAway = targets.every((item) => {
+      const element = vue.unref(item);
+      return element && !element.contains(event.target);
+    });
+    if (isClickAway) {
+      listener(event);
+    }
+  };
+  useEventListener(eventName, onClick, { target: document });
+}
+var width;
+var height;
+function useWindowSize() {
+  if (!width) {
+    width = vue.ref(0);
+    height = vue.ref(0);
+    if (inBrowser) {
+      const update = () => {
+        width.value = window.innerWidth;
+        height.value = window.innerHeight;
+      };
+      update();
+      window.addEventListener("resize", update, { passive: true });
+      window.addEventListener("orientationchange", update, { passive: true });
+    }
+  }
+  return { width, height };
+}
+var overflowScrollReg = /scroll|auto|overlay/i;
+var defaultRoot = inBrowser ? window : void 0;
+function isElement(node) {
+  const ELEMENT_NODE_TYPE = 1;
+  return node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === ELEMENT_NODE_TYPE;
+}
+function getScrollParent(el, root = defaultRoot) {
+  let node = el;
+  while (node && node !== root && isElement(node)) {
+    const { overflowY } = window.getComputedStyle(node);
+    if (overflowScrollReg.test(overflowY)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+}
+function useScrollParent(el, root = defaultRoot) {
+  const scrollParent = vue.ref();
+  vue.onMounted(() => {
+    if (el.value) {
+      scrollParent.value = getScrollParent(el.value, root);
+    }
+  });
+  return scrollParent;
+}
+var visibility;
+function usePageVisibility() {
+  if (!visibility) {
+    visibility = vue.ref("visible");
+    if (inBrowser) {
+      const update = () => {
+        visibility.value = document.hidden ? "hidden" : "visible";
+      };
+      update();
+      window.addEventListener("visibilitychange", update);
+    }
+  }
+  return visibility;
+}
+var CUSTOM_FIELD_INJECTION_KEY = Symbol("van-field");
+function useCustomFieldValue(customValue) {
+  const field = vue.inject(CUSTOM_FIELD_INJECTION_KEY, null);
+  if (field && !field.customValue.value) {
+    field.customValue.value = customValue;
+    vue.watch(customValue, () => {
+      field.resetValidation();
+      field.validateWithTrigger("onChange");
+    });
+  }
+}
+exports.CUSTOM_FIELD_INJECTION_KEY = CUSTOM_FIELD_INJECTION_KEY;
+exports.cancelRaf = cancelRaf;
+exports.doubleRaf = doubleRaf;
+exports.flattenVNodes = flattenVNodes;
+exports.getScrollParent = getScrollParent;
+exports.inBrowser = inBrowser;
+exports.onMountedOrActivated = onMountedOrActivated;
+exports.raf = raf;
+exports.sortChildren = sortChildren;
+exports.useChildren = useChildren;
+exports.useClickAway = useClickAway;
+exports.useCustomFieldValue = useCustomFieldValue;
+exports.useEventListener = useEventListener;
+exports.usePageVisibility = usePageVisibility;
+exports.useParent = useParent;
+exports.useRect = useRect;
+exports.useScrollParent = useScrollParent;
+exports.useToggle = useToggle;
+exports.useWindowSize = useWindowSize;

package/lib/node_modules/.pnpm/@vue_shared@3.5.13/node_modules/@vue/shared/dist/shared.esm-bundler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+/**
+* @vue/shared v3.5.13
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+!!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+!!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const isArray = Array.isArray;
+const isString = (val) => typeof val === "string";
+const isObject = (val) => val !== null && typeof val === "object";
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value) || isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  if (!styles) return "";
+  if (isString(styles)) return styles;
+  let ret = "";
+  for (const key in styles) {
+    const value = styles[key];
+    if (isString(value) || typeof value === "number") {
+      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+      ret += `${normalizedKey}:${value};`;
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+exports.hyphenate = hyphenate;
+exports.isArray = isArray;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.normalizeClass = normalizeClass;
+exports.normalizeStyle = normalizeStyle;
+exports.parseStringStyle = parseStringStyle;
+exports.stringifyStyle = stringifyStyle;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/action-bar/ActionBar.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index_esm = require("../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.js");
+const usePlaceholder = require("../composables/use-placeholder.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("action-bar");
+const ACTION_BAR_KEY = Symbol(name);
+const actionBarProps = {
+  placeholder: Boolean,
+  safeAreaInsetBottom: props.truthProp
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: actionBarProps,
+  setup(props2, {
+    slots
+  }) {
+    const root = vue.ref();
+    const renderPlaceholder = usePlaceholder.usePlaceholder(root, bem);
+    const {
+      linkChildren
+    } = index_esm.useChildren(ACTION_BAR_KEY);
+    linkChildren();
+    const renderActionBar = () => {
+      var _a;
+      return vue.createVNode("div", {
+        "ref": root,
+        "class": [bem(), {
+          "van-safe-area-bottom": props2.safeAreaInsetBottom
+        }]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+    return () => {
+      if (props2.placeholder) {
+        return renderPlaceholder(renderActionBar);
+      }
+      return renderActionBar();
+    };
+  }
+});
+exports.ACTION_BAR_KEY = ACTION_BAR_KEY;
+exports.actionBarProps = actionBarProps;
+exports.default = stdin_default;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/action-bar/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ActionBar$1 = require("./ActionBar.js");
+const withInstall = require("../utils/with-install.js");
+const ActionBar = withInstall.withInstall(ActionBar$1.default);
+exports.actionBarProps = ActionBar$1.actionBarProps;
+exports.ActionBar = ActionBar;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/action-sheet/ActionSheet.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index$1 = require("../icon/index.js");
+const index = require("../popup/index.js");
+const index$2 = require("../loading/index.js");
+const shared = require("../popup/shared.js");
+const basic = require("../utils/basic.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const constant = require("../utils/constant.js");
+const [name, bem] = create.createNamespace("action-sheet");
+const actionSheetProps = basic.extend({}, shared.popupSharedProps, {
+  title: String,
+  round: props.truthProp,
+  actions: props.makeArrayProp(),
+  closeIcon: props.makeStringProp("cross"),
+  closeable: props.truthProp,
+  cancelText: String,
+  description: String,
+  closeOnPopstate: props.truthProp,
+  closeOnClickAction: Boolean,
+  safeAreaInsetBottom: props.truthProp
+});
+const popupInheritKeys = [...shared.popupSharedPropKeys, "round", "closeOnPopstate", "safeAreaInsetBottom"];
+var stdin_default = vue.defineComponent({
+  name,
+  props: actionSheetProps,
+  emits: ["select", "cancel", "update:show"],
+  setup(props2, {
+    slots,
+    emit
+  }) {
+    const updateShow = (show) => emit("update:show", show);
+    const onCancel = () => {
+      updateShow(false);
+      emit("cancel");
+    };
+    const renderHeader = () => {
+      if (props2.title) {
+        return vue.createVNode("div", {
+          "class": bem("header")
+        }, [props2.title, props2.closeable && vue.createVNode(index$1.Icon, {
+          "name": props2.closeIcon,
+          "class": [bem("close"), constant.HAPTICS_FEEDBACK],
+          "onClick": onCancel
+        }, null)]);
+      }
+    };
+    const renderCancel = () => {
+      if (slots.cancel || props2.cancelText) {
+        return [vue.createVNode("div", {
+          "class": bem("gap")
+        }, null), vue.createVNode("button", {
+          "type": "button",
+          "class": bem("cancel"),
+          "onClick": onCancel
+        }, [slots.cancel ? slots.cancel() : props2.cancelText])];
+      }
+    };
+    const renderIcon = (action) => {
+      if (action.icon) {
+        return vue.createVNode(index$1.Icon, {
+          "class": bem("item-icon"),
+          "name": action.icon
+        }, null);
+      }
+    };
+    const renderActionContent = (action, index2) => {
+      if (action.loading) {
+        return vue.createVNode(index$2.Loading, {
+          "class": bem("loading-icon")
+        }, null);
+      }
+      if (slots.action) {
+        return slots.action({
+          action,
+          index: index2
+        });
+      }
+      return [vue.createVNode("span", {
+        "class": bem("name")
+      }, [action.name]), action.subname && vue.createVNode("div", {
+        "class": bem("subname")
+      }, [action.subname])];
+    };
+    const renderAction = (action, index2) => {
+      const {
+        color,
+        loading,
+        callback,
+        disabled,
+        className
+      } = action;
+      const onClick = () => {
+        if (disabled || loading) {
+          return;
+        }
+        if (callback) {
+          callback(action);
+        }
+        if (props2.closeOnClickAction) {
+          updateShow(false);
+        }
+        vue.nextTick(() => emit("select", action, index2));
+      };
+      return vue.createVNode("button", {
+        "type": "button",
+        "style": {
+          color
+        },
+        "class": [bem("item", {
+          loading,
+          disabled
+        }), className],
+        "onClick": onClick
+      }, [renderIcon(action), renderActionContent(action, index2)]);
+    };
+    const renderDescription = () => {
+      if (props2.description || slots.description) {
+        const content = slots.description ? slots.description() : props2.description;
+        return vue.createVNode("div", {
+          "class": bem("description")
+        }, [content]);
+      }
+    };
+    return () => vue.createVNode(index.Popup, vue.mergeProps({
+      "class": bem(),
+      "position": "bottom",
+      "onUpdate:show": updateShow
+    }, basic.pick(props2, popupInheritKeys)), {
+      default: () => {
+        var _a;
+        return [renderHeader(), renderDescription(), vue.createVNode("div", {
+          "class": bem("content")
+        }, [props2.actions.map(renderAction), (_a = slots.default) == null ? void 0 : _a.call(slots)]), renderCancel()];
+      }
+    });
+  }
+});
+exports.actionSheetProps = actionSheetProps;
+exports.default = stdin_default;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/action-sheet/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ActionSheet$1 = require("./ActionSheet.js");
+const withInstall = require("../utils/with-install.js");
+const ActionSheet = withInstall.withInstall(ActionSheet$1.default);
+exports.actionSheetProps = ActionSheet$1.actionSheetProps;
+exports.ActionSheet = ActionSheet;