@fecp/designer 5.5.113 → 5.5.115

package/lib/node_modules/vant/es/tree-select/TreeSelect.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index$2 = require("../icon/index.js");
+const index$1 = require("../sidebar/index.js");
+const index = require("../sidebar-item/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("tree-select");
+const treeSelectProps = {
+  max: props.makeNumericProp(Infinity),
+  items: props.makeArrayProp(),
+  height: props.makeNumericProp(300),
+  selectedIcon: props.makeStringProp("success"),
+  mainActiveIndex: props.makeNumericProp(0),
+  activeId: {
+    type: [Number, String, Array],
+    default: 0
+  }
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: treeSelectProps,
+  emits: ["clickNav", "clickItem", "update:activeId", "update:mainActiveIndex"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const isActiveItem = (id) => Array.isArray(props2.activeId) ? props2.activeId.includes(id) : props2.activeId === id;
+    const renderSubItem = (item) => {
+      const onClick = () => {
+        if (item.disabled) {
+          return;
+        }
+        let activeId;
+        if (Array.isArray(props2.activeId)) {
+          activeId = props2.activeId.slice();
+          const index2 = activeId.indexOf(item.id);
+          if (index2 !== -1) {
+            activeId.splice(index2, 1);
+          } else if (activeId.length < +props2.max) {
+            activeId.push(item.id);
+          }
+        } else {
+          activeId = item.id;
+        }
+        emit("update:activeId", activeId);
+        emit("clickItem", item);
+      };
+      return Vue.createVNode("div", {
+        "key": item.id,
+        "class": ["van-ellipsis", bem("item", {
+          active: isActiveItem(item.id),
+          disabled: item.disabled
+        })],
+        "onClick": onClick
+      }, [item.text, isActiveItem(item.id) && Vue.createVNode(index$2.Icon, {
+        "name": props2.selectedIcon,
+        "class": bem("selected")
+      }, null)]);
+    };
+    const onSidebarChange = (index2) => {
+      emit("update:mainActiveIndex", index2);
+    };
+    const onClickSidebarItem = (index2) => emit("clickNav", index2);
+    const renderSidebar = () => {
+      const Items = props2.items.map((item) => Vue.createVNode(index.SidebarItem, {
+        "dot": item.dot,
+        "badge": item.badge,
+        "class": [bem("nav-item"), item.className],
+        "disabled": item.disabled,
+        "onClick": onClickSidebarItem
+      }, {
+        title: () => slots["nav-text"] ? slots["nav-text"](item) : item.text
+      }));
+      return Vue.createVNode(index$1.Sidebar, {
+        "class": bem("nav"),
+        "modelValue": props2.mainActiveIndex,
+        "onChange": onSidebarChange
+      }, {
+        default: () => [Items]
+      });
+    };
+    const renderContent = () => {
+      if (slots.content) {
+        return slots.content();
+      }
+      const selected = props2.items[+props2.mainActiveIndex] || {};
+      if (selected.children) {
+        return selected.children.map(renderSubItem);
+      }
+    };
+    return () => Vue.createVNode("div", {
+      "class": bem(),
+      "style": {
+        height: format.addUnit(props2.height)
+      }
+    }, [renderSidebar(), Vue.createVNode("div", {
+      "class": bem("content")
+    }, [renderContent()])]);
+  }
+});
+exports.default = stdin_default;
+exports.treeSelectProps = treeSelectProps;

package/lib/node_modules/vant/es/tree-select/index.js

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

package/lib/node_modules/vant/es/uploader/Uploader.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const utils = require("./utils.js");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const useExpose = require("../composables/use-expose.js");
+const index = require("../icon/index.js");
+require("../image-preview/index.js");
+const UploaderPreviewItem = require("./UploaderPreviewItem.js");
+const functionCall = require("../image-preview/function-call.js");
+const props = require("../utils/props.js");
+const format = require("../utils/format.js");
+const basic = require("../utils/basic.js");
+const uploaderProps = {
+  name: props.makeNumericProp(""),
+  accept: props.makeStringProp("image/*"),
+  capture: String,
+  multiple: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  lazyLoad: Boolean,
+  maxCount: props.makeNumericProp(Infinity),
+  imageFit: props.makeStringProp("cover"),
+  resultType: props.makeStringProp("dataUrl"),
+  uploadIcon: props.makeStringProp("photograph"),
+  uploadText: String,
+  deletable: props.truthProp,
+  reupload: Boolean,
+  afterRead: Function,
+  showUpload: props.truthProp,
+  modelValue: props.makeArrayProp(),
+  beforeRead: Function,
+  beforeDelete: Function,
+  previewSize: [Number, String, Array],
+  previewImage: props.truthProp,
+  previewOptions: Object,
+  previewFullImage: props.truthProp,
+  maxSize: {
+    type: [Number, String, Function],
+    default: Infinity
+  }
+};
+var stdin_default = Vue.defineComponent({
+  name: utils.name,
+  props: uploaderProps,
+  emits: ["delete", "oversize", "clickUpload", "closePreview", "clickPreview", "clickReupload", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const inputRef = Vue.ref();
+    const urls = [];
+    const reuploadIndex = Vue.ref(-1);
+    const isReuploading = Vue.ref(false);
+    const getDetail = (index2 = props2.modelValue.length) => ({
+      name: props2.name,
+      index: index2
+    });
+    const resetInput = () => {
+      if (inputRef.value) {
+        inputRef.value.value = "";
+      }
+    };
+    const onAfterRead = (items) => {
+      resetInput();
+      if (utils.isOversize(items, props2.maxSize)) {
+        if (Array.isArray(items)) {
+          const result = utils.filterFiles(items, props2.maxSize);
+          items = result.valid;
+          emit("oversize", result.invalid, getDetail());
+          if (!items.length) {
+            return;
+          }
+        } else {
+          emit("oversize", items, getDetail());
+          return;
+        }
+      }
+      items = Vue.reactive(items);
+      if (reuploadIndex.value > -1) {
+        const arr = [...props2.modelValue];
+        arr.splice(reuploadIndex.value, 1, items);
+        emit("update:modelValue", arr);
+        reuploadIndex.value = -1;
+      } else {
+        emit("update:modelValue", [...props2.modelValue, ...basic.toArray(items)]);
+      }
+      if (props2.afterRead) {
+        props2.afterRead(items, getDetail());
+      }
+    };
+    const readFile = (files) => {
+      const {
+        maxCount,
+        modelValue,
+        resultType
+      } = props2;
+      if (Array.isArray(files)) {
+        const remainCount = +maxCount - modelValue.length;
+        if (files.length > remainCount) {
+          files = files.slice(0, remainCount);
+        }
+        Promise.all(files.map((file) => utils.readFileContent(file, resultType))).then((contents) => {
+          const fileList = files.map((file, index2) => {
+            const result = {
+              file,
+              status: "",
+              message: "",
+              objectUrl: URL.createObjectURL(file)
+            };
+            if (contents[index2]) {
+              result.content = contents[index2];
+            }
+            return result;
+          });
+          onAfterRead(fileList);
+        });
+      } else {
+        utils.readFileContent(files, resultType).then((content) => {
+          const result = {
+            file: files,
+            status: "",
+            message: "",
+            objectUrl: URL.createObjectURL(files)
+          };
+          if (content) {
+            result.content = content;
+          }
+          onAfterRead(result);
+        });
+      }
+    };
+    const onChange = (event) => {
+      const {
+        files
+      } = event.target;
+      if (props2.disabled || !files || !files.length) {
+        return;
+      }
+      const file = files.length === 1 ? files[0] : [].slice.call(files);
+      if (props2.beforeRead) {
+        const response = props2.beforeRead(file, getDetail());
+        if (!response) {
+          resetInput();
+          return;
+        }
+        if (basic.isPromise(response)) {
+          response.then((data) => {
+            if (data) {
+              readFile(data);
+            } else {
+              readFile(file);
+            }
+          }).catch(resetInput);
+          return;
+        }
+      }
+      readFile(file);
+    };
+    let imagePreview;
+    const onClosePreview = () => emit("closePreview");
+    const previewImage = (item) => {
+      if (props2.previewFullImage) {
+        const imageFiles = props2.modelValue.filter(utils.isImageFile);
+        const images = imageFiles.map((item2) => {
+          if (item2.objectUrl && !item2.url && item2.status !== "failed") {
+            item2.url = item2.objectUrl;
+            urls.push(item2.url);
+          }
+          return item2.url;
+        }).filter(Boolean);
+        imagePreview = functionCall.showImagePreview(basic.extend({
+          images,
+          startPosition: imageFiles.indexOf(item),
+          onClose: onClosePreview
+        }, props2.previewOptions));
+      }
+    };
+    const closeImagePreview = () => {
+      if (imagePreview) {
+        imagePreview.close();
+      }
+    };
+    const deleteFile = (item, index2) => {
+      const fileList = props2.modelValue.slice(0);
+      fileList.splice(index2, 1);
+      emit("update:modelValue", fileList);
+      emit("delete", item, getDetail(index2));
+    };
+    const reuploadFile = (index2) => {
+      isReuploading.value = true;
+      reuploadIndex.value = index2;
+      Vue.nextTick(() => chooseFile());
+    };
+    const onInputClick = () => {
+      if (!isReuploading.value) {
+        reuploadIndex.value = -1;
+      }
+      isReuploading.value = false;
+    };
+    const renderPreviewItem = (item, index2) => {
+      const needPickData = ["imageFit", "deletable", "reupload", "previewSize", "beforeDelete"];
+      const previewData = basic.extend(basic.pick(props2, needPickData), basic.pick(item, needPickData, true));
+      return Vue.createVNode(UploaderPreviewItem.default, Vue.mergeProps({
+        "item": item,
+        "index": index2,
+        "onClick": () => emit(props2.reupload ? "clickReupload" : "clickPreview", item, getDetail(index2)),
+        "onDelete": () => deleteFile(item, index2),
+        "onPreview": () => previewImage(item),
+        "onReupload": () => reuploadFile(index2)
+      }, basic.pick(props2, ["name", "lazyLoad"]), previewData), basic.pick(slots, ["preview-cover", "preview-delete"]));
+    };
+    const renderPreviewList = () => {
+      if (props2.previewImage) {
+        return props2.modelValue.map(renderPreviewItem);
+      }
+    };
+    const onClickUpload = (event) => emit("clickUpload", event);
+    const renderUpload = () => {
+      const lessThanMax = props2.modelValue.length < +props2.maxCount;
+      const Input = props2.readonly ? null : Vue.createVNode("input", {
+        "ref": inputRef,
+        "type": "file",
+        "class": utils.bem("input"),
+        "accept": props2.accept,
+        "capture": props2.capture,
+        "multiple": props2.multiple && reuploadIndex.value === -1,
+        "disabled": props2.disabled,
+        "onChange": onChange,
+        "onClick": onInputClick
+      }, null);
+      if (slots.default) {
+        return Vue.withDirectives(Vue.createVNode("div", {
+          "class": utils.bem("input-wrapper"),
+          "onClick": onClickUpload
+        }, [slots.default(), Input]), [[Vue.vShow, lessThanMax]]);
+      }
+      return Vue.withDirectives(Vue.createVNode("div", {
+        "class": utils.bem("upload", {
+          readonly: props2.readonly
+        }),
+        "style": format.getSizeStyle(props2.previewSize),
+        "onClick": onClickUpload
+      }, [Vue.createVNode(index.Icon, {
+        "name": props2.uploadIcon,
+        "class": utils.bem("upload-icon")
+      }, null), props2.uploadText && Vue.createVNode("span", {
+        "class": utils.bem("upload-text")
+      }, [props2.uploadText]), Input]), [[Vue.vShow, props2.showUpload && lessThanMax]]);
+    };
+    const chooseFile = () => {
+      if (inputRef.value && !props2.disabled) {
+        inputRef.value.click();
+      }
+    };
+    Vue.onBeforeUnmount(() => {
+      urls.forEach((url) => URL.revokeObjectURL(url));
+    });
+    useExpose.useExpose({
+      chooseFile,
+      reuploadFile,
+      closeImagePreview
+    });
+    index_esm.useCustomFieldValue(() => props2.modelValue);
+    return () => Vue.createVNode("div", {
+      "class": utils.bem()
+    }, [Vue.createVNode("div", {
+      "class": utils.bem("wrapper", {
+        disabled: props2.disabled
+      })
+    }, [renderPreviewList(), renderUpload()])]);
+  }
+});
+exports.default = stdin_default;
+exports.uploaderProps = uploaderProps;

package/lib/node_modules/vant/es/uploader/UploaderPreviewItem.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const utils = require("./utils.js");
+const index$1 = require("../icon/index.js");
+const index = require("../image/index.js");
+const index$2 = require("../loading/index.js");
+const props = require("../utils/props.js");
+const format = require("../utils/format.js");
+const basic = require("../utils/basic.js");
+const interceptor = require("../utils/interceptor.js");
+var stdin_default = Vue.defineComponent({
+  props: {
+    name: props.numericProp,
+    item: props.makeRequiredProp(Object),
+    index: Number,
+    imageFit: String,
+    lazyLoad: Boolean,
+    deletable: Boolean,
+    reupload: Boolean,
+    previewSize: [Number, String, Array],
+    beforeDelete: Function
+  },
+  emits: ["delete", "preview", "reupload"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const renderMask = () => {
+      const {
+        status,
+        message
+      } = props2.item;
+      if (status === "uploading" || status === "failed") {
+        const MaskIcon = status === "failed" ? Vue.createVNode(index$1.Icon, {
+          "name": "close",
+          "class": utils.bem("mask-icon")
+        }, null) : Vue.createVNode(index$2.Loading, {
+          "class": utils.bem("loading")
+        }, null);
+        const showMessage = basic.isDef(message) && message !== "";
+        return Vue.createVNode("div", {
+          "class": utils.bem("mask")
+        }, [MaskIcon, showMessage && Vue.createVNode("div", {
+          "class": utils.bem("mask-message")
+        }, [message])]);
+      }
+    };
+    const onDelete = (event) => {
+      const {
+        name,
+        item,
+        index: index2,
+        beforeDelete
+      } = props2;
+      event.stopPropagation();
+      interceptor.callInterceptor(beforeDelete, {
+        args: [item, {
+          name,
+          index: index2
+        }],
+        done: () => emit("delete")
+      });
+    };
+    const onPreview = () => emit("preview");
+    const onReupload = () => emit("reupload");
+    const renderDeleteIcon = () => {
+      if (props2.deletable && props2.item.status !== "uploading") {
+        const slot = slots["preview-delete"];
+        return Vue.createVNode("div", {
+          "role": "button",
+          "class": utils.bem("preview-delete", {
+            shadow: !slot
+          }),
+          "tabindex": 0,
+          "aria-label": utils.t("delete"),
+          "onClick": onDelete
+        }, [slot ? slot() : Vue.createVNode(index$1.Icon, {
+          "name": "cross",
+          "class": utils.bem("preview-delete-icon")
+        }, null)]);
+      }
+    };
+    const renderCover = () => {
+      if (slots["preview-cover"]) {
+        const {
+          index: index2,
+          item
+        } = props2;
+        return Vue.createVNode("div", {
+          "class": utils.bem("preview-cover")
+        }, [slots["preview-cover"](basic.extend({
+          index: index2
+        }, item))]);
+      }
+    };
+    const renderPreview = () => {
+      const {
+        item,
+        lazyLoad,
+        imageFit,
+        previewSize,
+        reupload
+      } = props2;
+      if (utils.isImageFile(item)) {
+        return Vue.createVNode(index.Image, {
+          "fit": imageFit,
+          "src": item.objectUrl || item.content || item.url,
+          "class": utils.bem("preview-image"),
+          "width": Array.isArray(previewSize) ? previewSize[0] : previewSize,
+          "height": Array.isArray(previewSize) ? previewSize[1] : previewSize,
+          "lazyLoad": lazyLoad,
+          "onClick": reupload ? onReupload : onPreview
+        }, {
+          default: renderCover
+        });
+      }
+      return Vue.createVNode("div", {
+        "class": utils.bem("file"),
+        "style": format.getSizeStyle(props2.previewSize)
+      }, [Vue.createVNode(index$1.Icon, {
+        "class": utils.bem("file-icon"),
+        "name": "description"
+      }, null), Vue.createVNode("div", {
+        "class": [utils.bem("file-name"), "van-ellipsis"]
+      }, [item.file ? item.file.name : item.url]), renderCover()]);
+    };
+    return () => Vue.createVNode("div", {
+      "class": utils.bem("preview")
+    }, [renderPreview(), renderMask(), renderDeleteIcon()]);
+  }
+});
+exports.default = stdin_default;

package/lib/node_modules/vant/es/uploader/index.js

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

package/lib/node_modules/vant/es/uploader/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const [name, bem, t] = create.createNamespace("uploader");
+function readFileContent(file, resultType) {
+  return new Promise((resolve) => {
+    if (resultType === "file") {
+      resolve();
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = (event) => {
+      resolve(event.target.result);
+    };
+    if (resultType === "dataUrl") {
+      reader.readAsDataURL(file);
+    } else if (resultType === "text") {
+      reader.readAsText(file);
+    }
+  });
+}
+function isOversize(items, maxSize) {
+  return basic.toArray(items).some((item) => {
+    if (item.file) {
+      if (basic.isFunction(maxSize)) {
+        return maxSize(item.file);
+      }
+      return item.file.size > +maxSize;
+    }
+    return false;
+  });
+}
+function filterFiles(items, maxSize) {
+  const valid = [];
+  const invalid = [];
+  items.forEach((item) => {
+    if (isOversize(item, maxSize)) {
+      invalid.push(item);
+    } else {
+      valid.push(item);
+    }
+  });
+  return { valid, invalid };
+}
+const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg|avif)/i;
+const isImageUrl = (url) => IMAGE_REGEXP.test(url);
+function isImageFile(item) {
+  if (item.isImage) {
+    return true;
+  }
+  if (item.file && item.file.type) {
+    return item.file.type.indexOf("image") === 0;
+  }
+  if (item.url) {
+    return isImageUrl(item.url);
+  }
+  if (typeof item.content === "string") {
+    return item.content.indexOf("data:image") === 0;
+  }
+  return false;
+}
+exports.bem = bem;
+exports.filterFiles = filterFiles;
+exports.isImageFile = isImageFile;
+exports.isImageUrl = isImageUrl;
+exports.isOversize = isOversize;
+exports.name = name;
+exports.readFileContent = readFileContent;
+exports.t = t;

package/lib/node_modules/vant/es/utils/basic.js

@@ -1,4 +1,56 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function noop() {
+}
 const extend = Object.assign;
+const inBrowser = typeof window !== "undefined";
+const isObject = (val) => val !== null && typeof val === "object";
+const isDef = (val) => val !== void 0 && val !== null;
+const isFunction = (val) => typeof val === "function";
+const isPromise = (val) => isObject(val) && isFunction(val.then) && isFunction(val.catch);
+const isDate = (val) => Object.prototype.toString.call(val) === "[object Date]" && !Number.isNaN(val.getTime());
+function isMobile(value) {
+  value = value.replace(/[^-|\d]/g, "");
+  return /^((\+86)|(86))?(1)\d{10}$/.test(value) || /^0[0-9-]{10,13}$/.test(value);
+}
+const isNumeric = (val) => typeof val === "number" || /^\d+(\.\d+)?$/.test(val);
+const isIOS = () => inBrowser ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;
+function get(object, path) {
+  const keys = path.split(".");
+  let result = object;
+  keys.forEach((key) => {
+    var _a;
+    result = isObject(result) ? (_a = result[key]) != null ? _a : "" : "";
+  });
+  return result;
+}
+function pick(obj, keys, ignoreUndefined) {
+  return keys.reduce(
+    (ret, key) => {
+      if (!ignoreUndefined || obj[key] !== void 0) {
+        ret[key] = obj[key];
+      }
+      return ret;
+    },
+    {}
+  );
+}
+const isSameValue = (newValue, oldValue) => JSON.stringify(newValue) === JSON.stringify(oldValue);
+const toArray = (item) => Array.isArray(item) ? item : [item];
+const flat = (arr) => arr.reduce((acc, val) => acc.concat(val), []);
 exports.extend = extend;
+exports.flat = flat;
+exports.get = get;
+exports.inBrowser = inBrowser;
+exports.isDate = isDate;
+exports.isDef = isDef;
+exports.isFunction = isFunction;
+exports.isIOS = isIOS;
+exports.isMobile = isMobile;
+exports.isNumeric = isNumeric;
+exports.isObject = isObject;
+exports.isPromise = isPromise;
+exports.isSameValue = isSameValue;
+exports.noop = noop;
+exports.pick = pick;
+exports.toArray = toArray;

package/lib/node_modules/vant/es/utils/closest.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function closest(arr, target) {
+  return arr.reduce(
+    (pre, cur) => Math.abs(pre - target) < Math.abs(cur - target) ? pre : cur
+  );
+}
+exports.closest = closest;

package/lib/node_modules/vant/es/utils/constant.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BORDER = "van-hairline";
+const BORDER_TOP = `${BORDER}--top`;
+const BORDER_LEFT = `${BORDER}--left`;
+const BORDER_RIGHT = `${BORDER}--right`;
+const BORDER_BOTTOM = `${BORDER}--bottom`;
+const BORDER_SURROUND = `${BORDER}--surround`;
+const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
+const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
+const HAPTICS_FEEDBACK = "van-haptics-feedback";
+const FORM_KEY = Symbol("van-form");
+const LONG_PRESS_START_TIME = 500;
+const TAP_OFFSET = 5;
+exports.BORDER = BORDER;
+exports.BORDER_BOTTOM = BORDER_BOTTOM;
+exports.BORDER_LEFT = BORDER_LEFT;
+exports.BORDER_RIGHT = BORDER_RIGHT;
+exports.BORDER_SURROUND = BORDER_SURROUND;
+exports.BORDER_TOP = BORDER_TOP;
+exports.BORDER_TOP_BOTTOM = BORDER_TOP_BOTTOM;
+exports.BORDER_UNSET_TOP_BOTTOM = BORDER_UNSET_TOP_BOTTOM;
+exports.FORM_KEY = FORM_KEY;
+exports.HAPTICS_FEEDBACK = HAPTICS_FEEDBACK;
+exports.LONG_PRESS_START_TIME = LONG_PRESS_START_TIME;
+exports.TAP_OFFSET = TAP_OFFSET;