@qsxy/element-plus-react 1.0.0-next.1

package/dist/Upload/ajax.js

@@ -0,0 +1,115 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Upload/ajax.ts
+var ajax_exports = {};
+__export(ajax_exports, {
+  ajaxUpload: () => ajaxUpload,
+  getBody: () => getBody,
+  getError: () => getError
+});
+module.exports = __toCommonJS(ajax_exports);
+var import_isNil = __toESM(require("lodash/isNil"));
+var import_typings = require("./typings");
+function getError(action, option, xhr) {
+  let msg;
+  if (xhr.response) {
+    msg = `${xhr.response.error || xhr.response}`;
+  } else if (xhr.responseText) {
+    msg = `${xhr.responseText}`;
+  } else {
+    msg = `fail to ${option.method} ${action} ${xhr.status}`;
+  }
+  return new import_typings.UploadAjaxError(msg, xhr.status, option.method, action);
+}
+function getBody(xhr) {
+  const text = xhr.responseText || xhr.response;
+  if (!text) {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+var ajaxUpload = (option) => {
+  if (typeof XMLHttpRequest === "undefined") {
+    throw new Error("XMLHttpRequest is undefined");
+  }
+  const xhr = new XMLHttpRequest();
+  const action = option.action;
+  if (xhr.upload) {
+    xhr.upload.addEventListener("progress", (evt) => {
+      const progressEvt = evt;
+      progressEvt.percent = evt.total > 0 ? evt.loaded / evt.total * 100 : 0;
+      option.onProgress(progressEvt);
+    });
+  }
+  const formData = new FormData();
+  if (option.data) {
+    if (!(option.data instanceof Function)) {
+      for (const [key, value] of Object.entries(option.data)) {
+        formData.append(key, value);
+      }
+    }
+  }
+  formData.append(option.filename, option.file, option.file.name);
+  xhr.addEventListener("error", () => {
+    option.onError(getError(action, option, xhr));
+  });
+  xhr.addEventListener("load", () => {
+    if (xhr.status < 200 || xhr.status >= 300) {
+      return option.onError(getError(action, option, xhr));
+    }
+    option.onSuccess(getBody(xhr));
+  });
+  xhr.open(option.method, action, true);
+  if (option.withCredentials && "withCredentials" in xhr) {
+    xhr.withCredentials = true;
+  }
+  const headers = option.headers || {};
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => xhr.setRequestHeader(key, value));
+  } else {
+    for (const [key, value] of Object.entries(headers)) {
+      if ((0, import_isNil.default)(value)) {
+        continue;
+      }
+      xhr.setRequestHeader(key, String(value));
+    }
+  }
+  xhr.send(formData);
+  return xhr;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ajaxUpload,
+  getBody,
+  getError
+});

package/dist/Upload/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Upload } from './Upload';
+export type { UploadFile, UploadFiles, UploadProps, UploadRawFile, UploadRef, UploadStatus, UploadUserFile } from './typings';

package/dist/Upload/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Upload/index.ts
+var Upload_exports = {};
+__export(Upload_exports, {
+  Upload: () => import_Upload.default
+});
+module.exports = __toCommonJS(Upload_exports);
+var import_Upload = __toESM(require("./Upload"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Upload
+});

package/dist/Upload/typings.d.ts

@@ -0,0 +1,110 @@
+import React from 'react';
+import { BaseProps, NativeProps } from '../types/common';
+export interface UploadBaseProps {
+    action: string;
+    headers?: Headers | Record<string, any>;
+    method?: 'post' | 'get';
+    multiple?: boolean;
+    data?: Record<string, any> | ((rawFile: UploadRawFile) => Promise<Record<string, any>>) | ((rawFile: UploadRawFile) => Record<string, any>);
+    name?: string;
+    drag?: boolean;
+    withCredentials?: boolean;
+    showFileList?: boolean;
+    accept?: string;
+    type?: string;
+    fileList?: UploadUserFile[];
+    listType?: 'text' | 'picture' | 'picture-card';
+    autoUpload?: boolean;
+    httpRequest?: (options: UploadRequestOptions) => XMLHttpRequest | Promise<unknown>;
+    disabled?: boolean;
+    limit?: number;
+}
+export interface UploadHooks {
+    beforeUpload?: (rawFile: UploadRawFile) => Awaitable<void | undefined | null | boolean | File | Blob>;
+    beforeRemove?: (uploadFile: UploadFile, uploadFiles: UploadFiles) => Awaitable<boolean>;
+    onRemove?: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+    onChange?: (uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+    onPreview?: (uploadFile: UploadFile) => void;
+    onSuccess?: (response: any, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+    onProgress?: (evt: UploadProgressEvent, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+    onError?: (error: Error, uploadFile: UploadFile, uploadFiles: UploadFiles) => void;
+    onExceed?: (files: File[], uploadFiles: UploadUserFile[]) => void;
+}
+export interface UploadContentProps extends UploadBaseProps, BaseProps {
+    beforeUpload?: UploadHooks['beforeUpload'];
+    onRemove?: (file: UploadFile | UploadRawFile) => void;
+    onStart?: (rawFile: UploadRawFile) => void;
+    onSuccess?: (response: any, rawFile: UploadRawFile) => unknown;
+    onProgress?: (evt: UploadProgressEvent, rawFile: UploadRawFile) => void;
+    onError?: (err: UploadAjaxError, rawFile: UploadRawFile) => void;
+    onExceed?: UploadHooks['onExceed'];
+}
+export interface UploadContentRef {
+    abort: (file?: UploadFile) => void;
+    upload: (rawFile: UploadRawFile) => Promise<void>;
+}
+export interface UploadRef {
+    abort: (file?: UploadFile) => void;
+    submit: () => void;
+    clearFiles: (status?: Array<'ready' | 'uploading' | 'success' | 'fail'>) => void;
+    handleStart: (rawFile: UploadRawFile) => void;
+    handleRemove: (file: UploadFile | UploadRawFile) => void;
+}
+export interface UploadProps extends UploadBaseProps, UploadHooks, BaseProps, NativeProps {
+    formatter?: (file: UploadFile) => React.ReactElement;
+    trigger?: React.ReactElement;
+    tip?: React.ReactElement;
+}
+export interface UploadListProps {
+    files?: UploadFiles;
+    setUploadFiles?: (files?: UploadFiles) => void;
+    disabled?: boolean;
+    handlePreview?: UploadHooks['onPreview'];
+    listType?: 'text' | 'picture' | 'picture-card';
+    onRemove?: (file: UploadFile | UploadRawFile) => void;
+    formatter?: (file: UploadFile) => React.ReactElement;
+    append?: React.ReactElement;
+}
+export type UploadStatus = 'ready' | 'uploading' | 'success' | 'fail';
+export interface UploadProgressEvent extends ProgressEvent {
+    percent: number;
+}
+export interface UploadRequestOptions {
+    action: string;
+    method: string;
+    data: Record<string, any> | (() => Promise<Record<string, any>>);
+    filename: string;
+    file: File;
+    headers: Headers | Record<string, string | number | null | undefined>;
+    onError: (evt: UploadAjaxError) => void;
+    onProgress: (evt: UploadProgressEvent) => void;
+    onSuccess: (response: any) => void;
+    withCredentials: boolean;
+}
+export interface UploadProgressEvent extends ProgressEvent {
+    percent: number;
+}
+export interface UploadFile {
+    name: string;
+    percentage?: number;
+    status: UploadStatus;
+    size?: number;
+    response?: unknown;
+    uid: number;
+    url?: string;
+    raw?: UploadRawFile;
+}
+export type UploadUserFile = Omit<UploadFile, 'status' | 'uid'> & Partial<Pick<UploadFile, 'status' | 'uid'>>;
+export type UploadFiles = UploadFile[];
+export interface UploadRawFile extends File {
+    uid: number;
+}
+export type UploadRequestHandler = (options: UploadRequestOptions) => XMLHttpRequest | Promise<unknown>;
+export declare class UploadAjaxError extends Error {
+    name: string;
+    status: number;
+    method: string;
+    url: string;
+    constructor(message: string, status: number, method: string, url: string);
+}
+export type Awaitable<T> = Promise<T> | T;

package/dist/Upload/typings.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Upload/typings.ts
+var typings_exports = {};
+__export(typings_exports, {
+  UploadAjaxError: () => UploadAjaxError
+});
+module.exports = __toCommonJS(typings_exports);
+var UploadAjaxError = class extends Error {
+  constructor(message, status, method, url) {
+    super(message);
+    this.name = "UploadAjaxError";
+    this.status = status;
+    this.method = method;
+    this.url = url;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UploadAjaxError
+});

package/dist/Upload/use-handlers.d.ts

@@ -0,0 +1,16 @@
+import { RefObject } from 'react';
+import { UploadContentRef, UploadFile, UploadFiles, UploadProps, UploadRawFile, UploadStatus } from './typings';
+export declare const useHandlers: (props: Omit<UploadProps, 'fileList'> & {
+    fileList: UploadFiles;
+}, uploadRef: RefObject<UploadContentRef | undefined>) => {
+    uploadFiles: UploadFiles;
+    setUploadFiles: (value: UploadFiles) => void;
+    abort: (file: UploadFile) => void;
+    clearFiles: (states?: UploadStatus[]) => void;
+    handleError: (err: import("./typings").UploadAjaxError, rawFile: UploadRawFile) => void;
+    handleProgress: (evt: import("./typings").UploadProgressEvent, rawFile: UploadRawFile) => void;
+    handleStart: (rawFile: UploadRawFile) => void;
+    handleSuccess: (response: any, rawFile: UploadRawFile) => unknown;
+    handleRemove: (file: UploadFile | UploadRawFile) => void;
+    submit: () => void;
+};

package/dist/Upload/use-handlers.js

@@ -0,0 +1,191 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Upload/use-handlers.ts
+var use_handlers_exports = {};
+__export(use_handlers_exports, {
+  useHandlers: () => useHandlers
+});
+module.exports = __toCommonJS(use_handlers_exports);
+var import_isNil = __toESM(require("lodash/isNil"));
+var import_react = require("react");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var revokeObjectURL = (file) => {
+  var _a;
+  if ((_a = file.url) == null ? void 0 : _a.startsWith("blob:")) {
+    URL.revokeObjectURL(file.url);
+  }
+};
+var useHandlers = (props, uploadRef) => {
+  const { fileList, listType, onError, onChange, onProgress, onSuccess, beforeRemove, onRemove } = props;
+  const uploadFilesRef = (0, import_react.useRef)();
+  const [uploadFiles, setUploadFiles, isControlled] = (0, import_hooks.useControlled)(fileList, []);
+  const { forceUpdate } = (0, import_hooks.useForceUpdate)();
+  (0, import_react.useEffect)(() => {
+    if (isControlled) {
+      uploadFilesRef.current = fileList.map((item) => {
+        return { uid: (0, import_Util.genFileId)(), status: "success", ...item };
+      });
+    }
+  }, [fileList]);
+  (0, import_react.useEffect)(() => {
+    uploadFilesRef.current = uploadFiles;
+  }, [uploadFiles]);
+  const getFile = (0, import_react.useCallback)((rawFile) => uploadFilesRef.current.find((file) => file.uid === rawFile.uid), []);
+  const abort = (file) => {
+    var _a;
+    (_a = uploadRef.current) == null ? void 0 : _a.abort(file);
+  };
+  const clearFiles = (states = ["ready", "uploading", "success", "fail"]) => {
+    uploadFilesRef.current = uploadFiles.filter((row) => !states.includes(row.status));
+    setUploadFiles(uploadFilesRef.current);
+    forceUpdate();
+  };
+  const handleError = (err, rawFile) => {
+    const file = getFile(rawFile);
+    if (!file) {
+      return;
+    }
+    file.status = "fail";
+    uploadFilesRef.current.splice(uploadFilesRef.current.indexOf(file), 1);
+    setUploadFiles(uploadFilesRef.current);
+    onError == null ? void 0 : onError(err, file, uploadFilesRef.current);
+    forceUpdate();
+  };
+  const handleProgress = (evt, rawFile) => {
+    const file = getFile(rawFile);
+    if (!file) {
+      return;
+    }
+    onProgress == null ? void 0 : onProgress(evt, file, uploadFilesRef.current);
+    file.status = "uploading";
+    file.percentage = Math.round(evt.percent);
+    forceUpdate();
+  };
+  const handleSuccess = (response, rawFile) => {
+    const file = getFile(rawFile);
+    if (!file) {
+      return;
+    }
+    file.status = "success";
+    file.response = response;
+    onSuccess == null ? void 0 : onSuccess(response, file, uploadFilesRef.current);
+    onChange == null ? void 0 : onChange(file, uploadFilesRef.current);
+    forceUpdate();
+  };
+  const handleStart = (file) => {
+    if ((0, import_isNil.default)(file.uid)) {
+      file.uid = (0, import_Util.genFileId)();
+    }
+    const uploadFile = {
+      name: file.name,
+      percentage: 0,
+      status: "ready",
+      size: file.size,
+      raw: file,
+      uid: file.uid
+    };
+    if (listType === "picture-card" || listType === "picture") {
+      try {
+        uploadFile.url = URL.createObjectURL(file);
+      } catch (err) {
+        (0, import_Util.warning)(false, err.message);
+        onError(err, uploadFile, uploadFilesRef.current);
+      }
+    }
+    uploadFilesRef.current = [...uploadFilesRef.current, uploadFile];
+    setUploadFiles(uploadFilesRef.current);
+    onChange == null ? void 0 : onChange(uploadFile, uploadFilesRef.current);
+  };
+  const handleRemove = async (file) => {
+    const uploadFile = file instanceof File ? getFile(file) : file;
+    if (!uploadFile) {
+      throw new Error("file to be removed not found");
+    }
+    const doRemove = (_file) => {
+      abort(_file);
+      const _fileList = JSON.parse(JSON.stringify(uploadFiles));
+      _fileList.splice(_fileList.indexOf(_file), 1);
+      uploadFilesRef.current = _fileList;
+      onRemove == null ? void 0 : onRemove(_file, uploadFilesRef.current);
+      revokeObjectURL(_file);
+      setUploadFiles(uploadFilesRef.current);
+      onChange == null ? void 0 : onChange(uploadFile, uploadFilesRef.current);
+      forceUpdate();
+    };
+    if (beforeRemove) {
+      const before = await beforeRemove(uploadFile, uploadFiles);
+      if (before !== false) {
+        doRemove(uploadFile);
+      }
+    } else {
+      doRemove(uploadFile);
+    }
+  };
+  const submit = () => {
+    uploadFilesRef.current.filter(({ status }) => status === "ready").forEach(({ raw }) => {
+      var _a;
+      return raw && ((_a = uploadRef.current) == null ? void 0 : _a.upload(raw));
+    });
+  };
+  (0, import_react.useEffect)(() => {
+    if (listType !== "picture-card" && listType !== "picture") {
+      return;
+    }
+    uploadFilesRef.current = uploadFiles.map((file) => {
+      const { raw, url } = file;
+      if (!url && raw) {
+        try {
+          file.url = URL.createObjectURL(raw);
+        } catch (err) {
+          onError == null ? void 0 : onError(err, file, uploadFiles);
+        }
+      }
+      return file;
+    });
+    setUploadFiles(uploadFilesRef.current);
+  }, [listType]);
+  return {
+    /** @description two-way binding ref from props `fileList` */
+    uploadFiles,
+    setUploadFiles,
+    abort,
+    clearFiles,
+    handleError,
+    handleProgress,
+    handleStart,
+    handleSuccess,
+    handleRemove,
+    submit
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHandlers
+});

package/dist/Util/Math.d.ts

@@ -0,0 +1,5 @@
+export declare function floatMultiply(arg1: number | string, arg2: number | string): number;
+export declare function floatDivide(arg1: number | string, arg2: number | string): number;
+export declare function floatAdd(arg1: string | number, arg2: string | number): number;
+export declare function floatSub(arg1: string | number, arg2: string | number): number;
+export declare const formatNumber: (value: number, precision: number) => string;

package/dist/Util/Math.js

@@ -0,0 +1,155 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Util/Math.ts
+var Math_exports = {};
+__export(Math_exports, {
+  floatAdd: () => floatAdd,
+  floatDivide: () => floatDivide,
+  floatMultiply: () => floatMultiply,
+  floatSub: () => floatSub,
+  formatNumber: () => formatNumber
+});
+module.exports = __toCommonJS(Math_exports);
+var import_isInteger = __toESM(require("lodash/isInteger"));
+var import_toFinite = __toESM(require("lodash/toFinite"));
+var toNonExponential = (num) => {
+  if (num == null) {
+    return num;
+  }
+  if (typeof num == "number") {
+    const m = num.toExponential().match(/\d(?:\.(\d*))?e([+-]\d+)/);
+    if (m) {
+      return num.toFixed(Math.max(0, (m[1] || "").length - (0, import_toFinite.default)(m[2])));
+    }
+    return num;
+  } else {
+    return num;
+  }
+};
+function floatMultiply(arg1, arg2) {
+  arg1 = Number(arg1);
+  arg2 = Number(arg2);
+  if (!arg1 && arg1 !== 0 || !arg2 && arg2 !== 0) {
+    return 0;
+  }
+  arg1 = toNonExponential(arg1);
+  arg2 = toNonExponential(arg2);
+  let r1, r2;
+  try {
+    r1 = arg1.toString().split(".")[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  try {
+    r2 = arg2.toString().split(".")[1].length;
+  } catch (e) {
+    r2 = 0;
+  }
+  const n1 = Number(arg1.toString().replace(".", ""));
+  const n2 = Number(arg2.toString().replace(".", ""));
+  return n1 * n2 / Math.pow(10, r1 + r2);
+}
+function floatDivide(arg1, arg2) {
+  arg1 = Number(arg1);
+  arg2 = Number(arg2);
+  if (!arg2) {
+    return null;
+  }
+  if (!arg1 && arg1 !== 0) {
+    return null;
+  } else if (arg1 === 0) {
+    return 0;
+  }
+  arg1 = toNonExponential(arg1);
+  arg2 = toNonExponential(arg2);
+  let r1, r2;
+  try {
+    r1 = arg1.toString().split(".")[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  try {
+    r2 = arg2.toString().split(".")[1].length;
+  } catch (e) {
+    r2 = 0;
+  }
+  const n1 = Number(arg1.toString().replace(".", ""));
+  const n2 = Number(arg2.toString().replace(".", ""));
+  return floatMultiply(n1 / n2, Math.pow(10, r2 - r1));
+}
+function floatAdd(arg1, arg2) {
+  arg1 = Number(arg1) || 0;
+  arg2 = Number(arg2) || 0;
+  arg1 = toNonExponential(arg1);
+  arg2 = toNonExponential(arg2);
+  let r1, r2;
+  try {
+    r1 = arg1.toString().split(".")[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  try {
+    r2 = arg2.toString().split(".")[1].length;
+  } catch (e) {
+    r2 = 0;
+  }
+  const m = Math.pow(10, Math.max(r1, r2));
+  return (floatMultiply(arg1, m) + floatMultiply(arg2, m)) / m;
+}
+function floatSub(arg1, arg2) {
+  arg1 = Number(arg1) || 0;
+  arg2 = Number(arg2) || 0;
+  arg1 = toNonExponential(arg1);
+  arg2 = toNonExponential(arg2);
+  let r1, r2;
+  try {
+    r1 = arg1.toString().split(".")[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  try {
+    r2 = arg2.toString().split(".")[1].length;
+  } catch (e) {
+    r2 = 0;
+  }
+  const m = Math.pow(10, Math.max(r1, r2));
+  const n = r1 >= r2 ? r1 : r2;
+  return (0, import_toFinite.default)(((floatMultiply(arg1, m) - floatMultiply(arg2, m)) / m).toFixed(n));
+}
+var formatNumber = (value, precision) => {
+  return (0, import_isInteger.default)(Math.abs(value)) && precision > 0 ? `${value}.${new Array(precision).fill(0).join("")}` : value.toFixed(precision);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  floatAdd,
+  floatDivide,
+  floatMultiply,
+  floatSub,
+  formatNumber
+});

package/dist/Util/PopupManager.d.ts

@@ -0,0 +1,5 @@
+declare const PopupManager: {
+    zIndex: number;
+    nextZIndex: () => number;
+};
+export default PopupManager;