@opentiny/vue-renderless 3.21.2 → 3.23.0

package/year-range/vue.js

@@ -2,32 +2,38 @@ import "../chunk-G2ADBYYC.js";
 import {
   handleChangeRange,
   resetView,
+  rightPrevYear,
   rightNextYear,
   isValidValue,
   handleConfirm,
   leftPrevYear,
+  leftNextYear,
   watchValue,
   handleShortcutClick,
   watchDefaultValue,
   handleRangePick,
   handleClear,
-  doPick
+  doPick,
+  watchModelValue
 } from "./index";
-import { DATEPICKER } from "../common";
-import { nextYear } from "../common/deps/date-util";
+import { DATEPICKER, nextYear } from "@opentiny/utils";
 const api = [
   "state",
+  "rightPrevYear",
   "rightNextYear",
   "handleRangePick",
   "handleShortcutClick",
   "handleChangeRange",
-  "leftPrevYear"
+  "leftPrevYear",
+  "leftNextYear",
+  "watchModelValue"
 ];
-const initState = ({ reactive, computed, api: api2, t }) => {
+const initState = ({ reactive, computed, api: api2, props, t }) => {
+  const initStartYear = Math.floor((/* @__PURE__ */ new Date()).getFullYear() / 10) * 10;
   const state = reactive({
     selectionMode: DATEPICKER.YearRange,
-    popperClass: "",
-    value: [],
+    popperClass: props.popperClass || "",
+    value: props.modelValue || [],
     defaultValue: null,
     defaultTime: null,
     minDate: "",
@@ -35,14 +41,17 @@ const initState = ({ reactive, computed, api: api2, t }) => {
     leftDate: /* @__PURE__ */ new Date(),
     rightDate: nextYear(/* @__PURE__ */ new Date()),
     rangeState: { startDate: null, endDate: null, selecting: false, row: null, column: null },
-    shortcuts: "",
+    shortcuts: props.shortcuts || [],
     visible: "",
-    disabledDate: "",
-    format: "",
+    disabledDate: props.disabledDate || null,
+    format: props.format || "",
     arrowControl: false,
-    unlinkPanels: false,
-    leftStartYear: Math.floor((/* @__PURE__ */ new Date()).getFullYear() / 10) * 10,
-    rightStartYear: computed(() => state.leftStartYear + DATEPICKER.PanelYearNum),
+    unlinkPanels: props.unlinkPanels || false,
+    leftStartYear: initStartYear,
+    rightStartYear: initStartYear + DATEPICKER.PanelYearNum,
+    enableYearArrow: computed(
+      () => props.unlinkPanels && state.rightStartYear > state.leftStartYear + DATEPICKER.PanelYearNum
+    ),
     btnDisabled: computed(
       () => !(state.minDate && state.maxDate && !state.selecting && api2.isValidValue([state.minDate, state.maxDate]))
     ),
@@ -62,22 +71,26 @@ const initState = ({ reactive, computed, api: api2, t }) => {
 const renderless = (props, { computed, reactive, watch }, { t, emit: $emit }) => {
   const emit = props.emitter ? props.emitter.emit : $emit;
   const api2 = {};
-  const state = initState({ reactive, computed, api: api2, t });
+  const state = initState({ reactive, computed, api: api2, props, t });
   Object.assign(api2, {
     state,
     doPick: doPick(emit),
     resetView: resetView(state),
     watchValue: watchValue({ state }),
     isValidValue: isValidValue(state),
-    leftPrevYear: leftPrevYear(state),
-    rightNextYear: rightNextYear(state),
+    leftPrevYear: leftPrevYear(state, api2),
+    leftNextYear: leftNextYear(state),
+    rightPrevYear: rightPrevYear(state),
+    rightNextYear: rightNextYear(state, api2),
     handleClear: handleClear({ emit, state }),
-    handleChangeRange: handleChangeRange(state),
-    handleShortcutClick: handleShortcutClick(api2),
+    handleChangeRange: handleChangeRange(state, props),
+    handleShortcutClick: handleShortcutClick(state, api2, props),
     watchDefaultValue: watchDefaultValue({ state }),
-    handleConfirm: handleConfirm({ api: api2, emit, state }),
-    handleRangePick: handleRangePick({ api: api2, state, t })
+    handleConfirm: handleConfirm({ api: api2, emit, state, props, t }),
+    handleRangePick: handleRangePick({ api: api2, state, props, t }),
+    watchModelValue: watchModelValue({ state })
   });
+  watch(() => props.modelValue, api2.watchModelValue, { immediate: true });
   watch(() => state.value, api2.watchValue);
   watch(() => state.defaultValue, api2.watchDefaultValue);
   return api2;

package/year-table/index.js

@@ -1,16 +1,18 @@
 import "../chunk-G2ADBYYC.js";
-import { toDate } from "../common/date";
+import { DATEPICKER, toDate1 } from "@opentiny/utils";
 import { arrayFindIndex, coerceTruthyValueToArray, arrayFind } from "../date-table";
-import { DATEPICKER } from "../common";
 const getIsDefault = ({ props }) => (year) => {
   const { defaultValue } = props;
   return Array.isArray(defaultValue) ? defaultValue.some((v) => v && v.getFullYear() === year) : defaultValue && defaultValue.getFullYear() === year;
 };
 const getIsDisabled = ({ props }) => (year) => {
-  return props.selectionMode.startsWith("year") && typeof props.disabledDate === "function" ? props.disabledDate(new Date(year, 0, 1, 0)) : false;
+  const MONTHS = Array.from({ length: 12 }, (_, i) => i);
+  return typeof props.disabledDate === "function" ? MONTHS.every(
+    (month) => props.disabledDate(new Date(year, month, 1))
+  ) : false;
 };
 const getIsCurrent = ({ props }) => (year) => {
-  const execDate = typeof props.value === "object" ? props.value : toDate(props.value);
+  const execDate = typeof props.value === "object" ? props.value : toDate1(props.value);
   return arrayFindIndex(coerceTruthyValueToArray(execDate), (date) => date.getFullYear() === year) >= 0;
 };
 const clearDate = (date) => {
@@ -93,7 +95,10 @@ const watchDate = ({ api, props }) => (value, oldvalue) => {
 };
 const handleYearTableClick = ({ emit, props }) => (event) => {
   const target = event.target;
-  const { selectionMode } = props;
+  const { selectionMode, readonly } = props;
+  if (readonly) {
+    return;
+  }
   if (target.tagName === "A") {
     if (target.hasAttribute("aria-disabled")) {
       return;

package/avatar/index.js

@@ -1,30 +0,0 @@
-import "../chunk-G2ADBYYC.js";
-const handleError = ({ props, state }) => () => {
-  const { error } = props;
-  const errorFlag = error ? error() : void 0;
-  if (errorFlag !== false) {
-    if (state.isSrcImageExist) {
-      state.isSrcImageExist = false;
-    } else {
-      state.isDefaultImageExist = false;
-    }
-  }
-};
-const computedAvatarClass = (contants) => (props) => {
-  const { size, icon, shape } = props;
-  let classList = [contants.COMPONENT_PREFIX];
-  if (size && typeof size === "string") {
-    classList.push(`${contants.COMPONENT_PREFIX}--${size}`);
-  }
-  if (icon) {
-    classList.push(`${contants.COMPONENT_PREFIX}--${contants.icon}`);
-  }
-  if (shape) {
-    classList.push(`${contants.COMPONENT_PREFIX}--${shape}`);
-  }
-  return classList.join(" ");
-};
-export {
-  computedAvatarClass,
-  handleError
-};

package/avatar/vue.js

@@ -1,22 +0,0 @@
-import "../chunk-G2ADBYYC.js";
-import { computedAvatarClass, handleError } from "./index";
-const api = ["state", "handleError"];
-const renderless = (props, { computed, reactive }, { constants }) => {
-  const api2 = {
-    computedAvatarClass: computedAvatarClass(constants)
-  };
-  const state = reactive({
-    isSrcImageExist: true,
-    isDefaultImageExist: true,
-    avatarClass: computed(() => api2.computedAvatarClass(props))
-  });
-  Object.assign(api2, {
-    state,
-    handleError: handleError({ props, state })
-  });
-  return api2;
-};
-export {
-  api,
-  renderless
-};

package/common/array.js

@@ -1,115 +0,0 @@
-import {
-  __spreadValues
-} from "../chunk-G2ADBYYC.js";
-import { SORT } from "./index";
-import { isSame } from "./type";
-import { getObj } from "./object";
-const indexOf = (arr, data, predicate = isSame) => {
-  if (Array.isArray(arr) && typeof predicate === "function") {
-    for (let i = 0, len = arr.length; i < len; i++) {
-      if (predicate(arr[i], data)) {
-        return i;
-      }
-    }
-  }
-  return -1;
-};
-const find = (arr, predicate) => {
-  const index = indexOf(arr, void 0, predicate);
-  return index !== -1 ? arr[index] : void 0;
-};
-const remove = (arr, data, count = 1) => {
-  if (Array.isArray(arr) && arr.length) {
-    const index = indexOf(arr, data);
-    if (index > -1) {
-      arr.splice(index, count);
-    }
-  }
-  return arr;
-};
-const sort = (arr, field, sort2 = SORT.Asc) => {
-  if (Array.isArray(arr) && arr.length > 1) {
-    arr.sort((x, y) => {
-      const compare = sort2 === SORT.Asc ? [1, -1] : [-1, 1];
-      const xField = getObj(x, field);
-      const yField = getObj(y, field);
-      if (isNaN(xField)) {
-        return sort2 === SORT.Asc ? 1 : -1;
-      } else if (isNaN(yField)) {
-        return -1;
-      }
-      return xField > yField ? compare[0] : compare[1];
-    });
-  }
-  return arr;
-};
-const push = (arr, data) => {
-  if (Array.isArray(arr) && !arr.some((value) => isSame(value, data))) {
-    arr.push(data);
-  }
-  return arr;
-};
-const unique = (arr) => {
-  if (Array.isArray(arr)) {
-    const array = [];
-    for (let i = 0, len = arr.length; i < len; i++) {
-      const value = arr[i];
-      if (indexOf(array, value) === -1) {
-        array.push(value);
-      }
-    }
-    return array;
-  }
-  return arr;
-};
-const extend = (to, _from) => {
-  Object.keys(_from).forEach((key) => to[key] = _from[key]);
-  return to;
-};
-const toObject = (arr) => {
-  const res = {};
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
-    }
-  }
-  return res;
-};
-const transformPidToChildren = (data, pidName = "pId", childrenName = "children", idName = "id") => {
-  const result = [];
-  Array.isArray(data) && data.forEach((item) => {
-    if (item[pidName] == "0") {
-      result.push(item);
-    } else {
-      const parent = find(data, (i) => i[idName] == item[pidName]);
-      if (!parent) {
-        return;
-      }
-      if (!parent[childrenName]) {
-        parent[childrenName] = [];
-      }
-      parent[childrenName].push(item);
-    }
-    delete item[pidName];
-  });
-  return result;
-};
-const transformTreeData = (data, key = "id", parentKey = "pId") => {
-  if (!Array.isArray(data)) {
-    data = [data];
-  }
-  data = data.map((item) => __spreadValues({}, item));
-  const treeData = transformPidToChildren(data, parentKey, "children", key);
-  return treeData;
-};
-export {
-  find,
-  indexOf,
-  push,
-  remove,
-  sort,
-  toObject,
-  transformPidToChildren,
-  transformTreeData,
-  unique
-};

package/common/bigInt.js

@@ -1,315 +0,0 @@
-import "../chunk-G2ADBYYC.js";
-import { fillChar } from "./string";
-import { isBrowser } from "./browser";
-const BigInt = isBrowser ? window.BigInt : global.BigInt;
-function supportBigInt() {
-  return typeof BigInt === "function";
-}
-function trimNumber(numStr) {
-  let string = numStr.toString().trim();
-  let negative = string.startsWith("-");
-  if (negative) {
-    string = string.slice(1);
-  }
-  string = string.replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, "");
-  if (string.startsWith(".")) {
-    string = "0".concat(string);
-  }
-  let trimStr = string || "0";
-  let splitNumber = trimStr.split(".");
-  let integerStr = splitNumber[0] || "0";
-  let decimalStr = splitNumber[1] || "0";
-  if (integerStr === "0" && decimalStr === "0") {
-    negative = false;
-  }
-  let negativeStr = negative ? "-" : "";
-  return {
-    negative,
-    negativeStr,
-    trimStr,
-    integerStr,
-    decimalStr,
-    fullStr: "".concat(negativeStr).concat(trimStr)
-  };
-}
-function isE(number) {
-  let str = String(number);
-  return !isNaN(Number(str)) && ~str.indexOf("e");
-}
-function validateNumber(num) {
-  if (typeof num === "number") {
-    return !isNaN(num);
-  }
-  if (!num) {
-    return false;
-  }
-  return (
-    // Normal type: 11.28
-    /^\s*-?\d+(\.\d+)?\s*$/.test(num) || // Pre-number: 1.
-    /^\s*-?\d+\.\s*$/.test(num) || // Post-number: .1
-    /^\s*-?\.\d+\s*$/.test(num)
-  );
-}
-function getNumberPrecision(number) {
-  let numStr = String(number);
-  if (isE(number)) {
-    let precision = Number(numStr.slice(numStr.indexOf("e-") + 2));
-    let decimalMatch = numStr.match(/\.(\d+)/);
-    if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) {
-      precision += decimalMatch[1].length;
-    }
-    return precision;
-  }
-  return ~numStr.indexOf(".") && validateNumber(numStr) ? numStr.length - numStr.indexOf(".") - 1 : 0;
-}
-function num2str(number) {
-  let numStr = String(number);
-  if (isE(number)) {
-    if (number > Number.MAX_SAFE_INTEGER) {
-      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
-    }
-    if (number < Number.MIN_SAFE_INTEGER) {
-      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
-    }
-    numStr = number.toFixed(getNumberPrecision(numStr));
-  }
-  return trimNumber(numStr).fullStr;
-}
-function pluginDecimal(decimal) {
-  if (!decimal.add) {
-    Object.assign(decimal, {
-      add: decimal.plus,
-      lessEquals: decimal.isLessThan,
-      equals: decimal.isEqualTo
-    });
-  }
-  return decimal;
-}
-const DecimalCls = {
-  CLS: null
-};
-let setDecimalClass;
-function getMiniDecimal(value, decimal) {
-  if (!DecimalCls.CLS) {
-    setDecimalClass(decimal);
-  }
-  return pluginDecimal(new DecimalCls.CLS(value));
-}
-class BigIntDecimal {
-  constructor(value) {
-    if (!value && value !== 0 || !String(value).trim()) {
-      this.empty = true;
-      return;
-    }
-    this.origin = String(value);
-    this.negative = void 0;
-    this.integer = void 0;
-    this.decimal = void 0;
-    this.decimalLen = void 0;
-    this.empty = void 0;
-    this.nan = void 0;
-    if (value === "-") {
-      this.nan = true;
-      return;
-    }
-    let mergedValue = isE(value) ? Number(value) : value;
-    if (typeof mergedValue !== "string") {
-      num2str(mergedValue);
-    }
-    const f = Function;
-    const convertBigInt = (str) => {
-      const validStr = str.replace(/^0+/, "") || "0";
-      return f(`return BigInt('${validStr}')`)();
-    };
-    if (validateNumber(mergedValue)) {
-      const trimRet = trimNumber(mergedValue);
-      this.negative = trimRet.negative;
-      const numbers = trimRet.trimStr.split(".");
-      this.integer = !numbers[0].includes("e") ? BigInt(numbers[0]) : numbers[0];
-      const decimalStr = numbers[1] || "0";
-      this.decimal = decimalStr.includes("e") ? convertBigInt(decimalStr) : BigInt(decimalStr);
-      this.decimalLen = decimalStr.length;
-    } else {
-      this.nan = true;
-    }
-  }
-  getDecimalStr() {
-    return this.decimal.toString().padStart(this.decimalLen, "0");
-  }
-  getIntegerStr() {
-    return this.integer.toString();
-  }
-  getMark() {
-    return this.negative ? "-" : "";
-  }
-  /**
-   * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
-   * This is used for add function only.
-   */
-  alignDecimal(decimalLength) {
-    const string = `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(decimalLength, "0")}`;
-    return BigInt(string);
-  }
-  add(value) {
-    if (this.isInvalidate()) {
-      return new BigIntDecimal(value);
-    }
-    const offsetObj = new BigIntDecimal(value);
-    if (offsetObj.isInvalidate()) {
-      return this;
-    }
-    const maxDecimalLength = Math.max(this.getDecimalStr().length, offsetObj.getDecimalStr().length);
-    const offsetAlignedDecimal = offsetObj.alignDecimal(maxDecimalLength);
-    const myAlignedDecimal = this.alignDecimal(maxDecimalLength);
-    const valueStr = `${myAlignedDecimal + offsetAlignedDecimal}`;
-    const { negativeStr: str, trimStr } = trimNumber(valueStr);
-    const hydrateValueStr = `${str}${trimStr.padStart(maxDecimalLength + 1, "0")}`;
-    return getMiniDecimal(`${hydrateValueStr.slice(0, -maxDecimalLength)}.${hydrateValueStr.slice(-maxDecimalLength)}`);
-  }
-  negate() {
-    const clone = new BigIntDecimal(this.toString());
-    clone.negative = !clone.negative;
-    return clone;
-  }
-  isNaN() {
-    return this.nan;
-  }
-  isEmpty() {
-    return this.empty;
-  }
-  isInvalidate() {
-    return this.isEmpty() || this.isNaN();
-  }
-  lessEquals(target) {
-    return this.add(target.negate().toString()).toNumber() <= 0;
-  }
-  equals(target) {
-    return this.toString() === (target && target.toString());
-  }
-  toNumber() {
-    if (this.isNaN()) {
-      return NaN;
-    }
-    return Number(this.toString());
-  }
-  toString(safe = true) {
-    if (!safe) {
-      return this.origin;
-    }
-    if (this.isInvalidate()) {
-      return "";
-    }
-    return trimNumber(`${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`).fullStr;
-  }
-}
-class NumberDecimal {
-  constructor(value = "") {
-    if (!value && value !== 0 || !String(value).trim()) {
-      this.empty = true;
-      return;
-    }
-    this.origin = "";
-    this.number = void 0;
-    this.empty = void 0;
-    this.origin = String(value);
-    this.number = Number(value);
-  }
-  negate() {
-    return new NumberDecimal(-this.toNumber());
-  }
-  add(value) {
-    if (this.isInvalidate()) {
-      return new NumberDecimal(value);
-    }
-    const target = Number(value);
-    if (isNaN(target)) {
-      return this;
-    }
-    const number = this.number + target;
-    if (number < Number.MIN_SAFE_INTEGER) {
-      return new NumberDecimal(Number.MIN_SAFE_INTEGER);
-    }
-    if (number > Number.MAX_SAFE_INTEGER) {
-      return new NumberDecimal(Number.MAX_SAFE_INTEGER);
-    }
-    const maxPrecision = Math.max(getNumberPrecision(target), getNumberPrecision(this.number));
-    return new NumberDecimal(number.toFixed(maxPrecision));
-  }
-  isNaN() {
-    return isNaN(this.number);
-  }
-  isEmpty() {
-    return this.empty;
-  }
-  isInvalidate() {
-    return this.isEmpty() || this.isNaN();
-  }
-  equals(target) {
-    return this.toNumber() === (target && target.toNumber());
-  }
-  lessEquals(target) {
-    return this.add(target.negate().toString()).toNumber() <= 0;
-  }
-  toNumber() {
-    return this.number;
-  }
-  toString(safe = true) {
-    if (!safe) {
-      return this.origin;
-    }
-    if (this.isInvalidate()) {
-      return "";
-    }
-    return num2str(this.number);
-  }
-}
-setDecimalClass = function(decimaljs) {
-  DecimalCls.CLS = supportBigInt() ? BigIntDecimal : typeof decimaljs === "function" ? decimaljs : NumberDecimal;
-};
-function lessEquals(value1, value2) {
-  return getMiniDecimal(value1).lessEquals(getMiniDecimal(value2));
-}
-function equalsDecimal(value1, value2) {
-  return getMiniDecimal(value1).equals(getMiniDecimal(value2));
-}
-function toFixed(numStr, precision, rounding = 5) {
-  if (numStr === "") {
-    return "";
-  }
-  const separatorStr = ".";
-  const { negativeStr, integerStr, decimalStr } = trimNumber(numStr);
-  const precisionDecimalStr = `${separatorStr}${decimalStr}`;
-  const numberWithoutDecimal = `${negativeStr}${integerStr}`;
-  if (precision >= 0) {
-    const advancedNum = Number(decimalStr[precision]);
-    if (advancedNum >= rounding && rounding !== 0) {
-      const advancedDecimal = getMiniDecimal(`${integerStr}${separatorStr}${decimalStr}`).add(
-        `0.${fillChar("", precision, true)}${10 - advancedNum}`
-      );
-      return toFixed(negativeStr + advancedDecimal.toString(), precision, 0);
-    }
-    if (precision === 0) {
-      return numberWithoutDecimal;
-    }
-    return `${numberWithoutDecimal}${separatorStr}${fillChar(decimalStr, precision, true).slice(0, precision)}`;
-  }
-  if (precisionDecimalStr === ".0") {
-    return numberWithoutDecimal;
-  }
-  return `${numberWithoutDecimal}${precisionDecimalStr}`;
-}
-export {
-  BigIntDecimal,
-  NumberDecimal,
-  equalsDecimal,
-  getMiniDecimal,
-  getNumberPrecision,
-  isE,
-  lessEquals,
-  num2str,
-  setDecimalClass,
-  supportBigInt,
-  toFixed,
-  trimNumber,
-  validateNumber
-};

package/common/browser.js

@@ -1,81 +0,0 @@
-import "../chunk-G2ADBYYC.js";
-const getIEVersion = () => {
-  let version = 8;
-  if (!!document.addEventListener && !!window.performance) {
-    version = 9;
-    if (!!window.atob && !!window.matchMedia) {
-      version = 10;
-      if (!window.attachEvent && !document.all) {
-        version = 11;
-      }
-    }
-  }
-  return version;
-};
-const isEdge = (browser) => {
-  if (browser.chrome && ~navigator.userAgent.indexOf("Edg")) {
-    browser.name = "edge";
-    browser.edge = true;
-    delete browser.chrome;
-  } else if (!document.documentMode && !!window.StyleMedia) {
-    browser.name = "edge";
-    browser.edge = true;
-  }
-};
-const isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && window.document === document;
-const globalEnvironment = isBrowser ? window : global;
-var browser_default = (() => {
-  const browser = {
-    name: void 0,
-    version: void 0,
-    isDoc: typeof document !== "undefined",
-    isMobile: false,
-    isPC: true,
-    isNode: typeof window === "undefined"
-  };
-  if (isBrowser) {
-    const isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
-    browser.isMobile = isMobile;
-    browser.isPC = !isMobile;
-    let matches;
-    if (!!window.chrome && (!!window.chrome.webstore || /^Google\b/.test(window.navigator.vendor))) {
-      browser.name = "chrome";
-      browser.chrome = true;
-      matches = navigator.userAgent.match(/chrome\/(\d+)/i);
-      browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
-      matches = void 0;
-    } else if (!!document.all || !!document.documentMode) {
-      browser.name = "ie";
-      browser.version = getIEVersion();
-      browser.ie = true;
-    } else if (typeof window.InstallTrigger !== "undefined") {
-      browser.name = "firefox";
-      browser.firefox = true;
-    } else if (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") > 0) {
-      browser.name = "safari";
-      browser.safari = true;
-    } else if (!!window.opr && !!window.opr.addons || !!window.opera) {
-      browser.name = "opera";
-      browser.opera = true;
-    }
-    isEdge(browser);
-    if (!~["ie", "chrome"].indexOf(browser.name)) {
-      const reg = browser.name + "/(\\d+)";
-      matches = navigator.userAgent.match(new RegExp(reg, "i"));
-      browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
-      matches = void 0;
-    }
-    if (browser.isDoc) {
-      const bodyEl = document.body || document.documentElement;
-      ["webkit", "khtml", "moz", "ms", "o"].forEach((core) => {
-        browser["-" + core] = !!bodyEl[core + "MatchesSelector"];
-      });
-    }
-  }
-  return browser;
-})();
-export {
-  browser_default as default,
-  globalEnvironment,
-  isBrowser
-};