@wfrog/vc-ui 1.0.0

package/dist/es/chunk/Ce9ApjrT.mjs

@@ -0,0 +1,201 @@
+import { defineComponent, computed, h, renderSlot, ref, watchEffect, createVNode, createTextVNode, isVNode, Comment } from 'vue';
+import { c as buildProps, u as useNamespace, i as isArray, f as isNumber, h as isString, d as definePropType } from './E_WRn0OP.mjs';
+import { P as PatchFlags, i as isFragment, a as isValidElementNode } from './B_tU9Nax.mjs';
+import { c as componentSizes } from './CS4VKsqy.mjs';
+import { w as withInstall } from './D389hx_T.mjs';
+
+const spaceItemProps = buildProps({
+  prefixCls: {
+    type: String
+  }
+});
+const SpaceItem = defineComponent({
+  name: "ElSpaceItem",
+  props: spaceItemProps,
+  setup(props, { slots }) {
+    const ns = useNamespace("space");
+    const classes = computed(() => `${props.prefixCls || ns.b()}__item`);
+    return () => h("div", { class: classes.value }, renderSlot(slots, "default"));
+  }
+});
+
+const SIZE_MAP = {
+  small: 8,
+  default: 12,
+  large: 16
+};
+function useSpace(props) {
+  const ns = useNamespace("space");
+  const classes = computed(() => [ns.b(), ns.m(props.direction), props.class]);
+  const horizontalSize = ref(0);
+  const verticalSize = ref(0);
+  const containerStyle = computed(() => {
+    const wrapKls = props.wrap || props.fill ? { flexWrap: "wrap" } : {};
+    const alignment = {
+      alignItems: props.alignment
+    };
+    const gap = {
+      rowGap: `${verticalSize.value}px`,
+      columnGap: `${horizontalSize.value}px`
+    };
+    return [wrapKls, alignment, gap, props.style];
+  });
+  const itemStyle = computed(() => {
+    return props.fill ? { flexGrow: 1, minWidth: `${props.fillRatio}%` } : {};
+  });
+  watchEffect(() => {
+    const { size = "small", wrap, direction: dir, fill } = props;
+    if (isArray(size)) {
+      const [h = 0, v = 0] = size;
+      horizontalSize.value = h;
+      verticalSize.value = v;
+    } else {
+      let val;
+      if (isNumber(size)) {
+        val = size;
+      } else {
+        val = SIZE_MAP[size || "small"] || SIZE_MAP.small;
+      }
+      if ((wrap || fill) && dir === "horizontal") {
+        horizontalSize.value = verticalSize.value = val;
+      } else {
+        if (dir === "horizontal") {
+          horizontalSize.value = val;
+          verticalSize.value = 0;
+        } else {
+          verticalSize.value = val;
+          horizontalSize.value = 0;
+        }
+      }
+    }
+  });
+  return {
+    classes,
+    containerStyle,
+    itemStyle
+  };
+}
+
+const spaceProps = buildProps({
+  direction: {
+    type: String,
+    values: ["horizontal", "vertical"],
+    default: "horizontal"
+  },
+  class: {
+    type: definePropType([
+      String,
+      Object,
+      Array
+    ]),
+    default: ""
+  },
+  style: {
+    type: definePropType([String, Array, Object]),
+    default: ""
+  },
+  alignment: {
+    type: definePropType(String),
+    default: "center"
+  },
+  prefixCls: {
+    type: String
+  },
+  spacer: {
+    type: definePropType([Object, String, Number, Array]),
+    default: null,
+    validator: (val) => isVNode(val) || isNumber(val) || isString(val)
+  },
+  wrap: Boolean,
+  fill: Boolean,
+  fillRatio: {
+    type: Number,
+    default: 100
+  },
+  size: {
+    type: [String, Array, Number],
+    values: componentSizes,
+    validator: (val) => {
+      return isNumber(val) || isArray(val) && val.length === 2 && val.every(isNumber);
+    }
+  }
+});
+const Space = defineComponent({
+  name: "ElSpace",
+  props: spaceProps,
+  setup(props, { slots }) {
+    const { classes, containerStyle, itemStyle } = useSpace(props);
+    function extractChildren(children, parentKey = "", extractedChildren = []) {
+      const { prefixCls } = props;
+      children.forEach((child, loopKey) => {
+        if (isFragment(child)) {
+          if (isArray(child.children)) {
+            child.children.forEach((nested, key) => {
+              if (isFragment(nested) && isArray(nested.children)) {
+                extractChildren(nested.children, `${parentKey + key}-`, extractedChildren);
+              } else {
+                if (isVNode(nested) && (nested == null ? void 0 : nested.type) === Comment) {
+                  extractedChildren.push(nested);
+                } else {
+                  extractedChildren.push(createVNode(SpaceItem, {
+                    style: itemStyle.value,
+                    prefixCls,
+                    key: `nested-${parentKey + key}`
+                  }, {
+                    default: () => [nested]
+                  }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
+                }
+              }
+            });
+          }
+        } else if (isValidElementNode(child)) {
+          extractedChildren.push(createVNode(SpaceItem, {
+            style: itemStyle.value,
+            prefixCls,
+            key: `LoopKey${parentKey + loopKey}`
+          }, {
+            default: () => [child]
+          }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
+        }
+      });
+      return extractedChildren;
+    }
+    return () => {
+      var _a;
+      const { spacer, direction } = props;
+      const children = renderSlot(slots, "default", { key: 0 }, () => []);
+      if (((_a = children.children) != null ? _a : []).length === 0)
+        return null;
+      if (isArray(children.children)) {
+        let extractedChildren = extractChildren(children.children);
+        if (spacer) {
+          const len = extractedChildren.length - 1;
+          extractedChildren = extractedChildren.reduce((acc, child, idx) => {
+            const children2 = [...acc, child];
+            if (idx !== len) {
+              children2.push(createVNode("span", {
+                style: [
+                  itemStyle.value,
+                  direction === "vertical" ? "width: 100%" : null
+                ],
+                key: idx
+              }, [
+                isVNode(spacer) ? spacer : createTextVNode(spacer, PatchFlags.TEXT)
+              ], PatchFlags.STYLE));
+            }
+            return children2;
+          }, []);
+        }
+        return createVNode("div", {
+          class: classes.value,
+          style: containerStyle.value
+        }, extractedChildren, PatchFlags.STYLE | PatchFlags.CLASS);
+      }
+      return children.children;
+    };
+  }
+});
+
+const ElSpace = withInstall(Space);
+
+export { ElSpace as E };

package/dist/es/chunk/ClZGuAIb.mjs

@@ -0,0 +1,10 @@
+function withInstall(main, extra) {
+  main.install = (app) => {
+    for (const comp of [main, ...Object.values({})]) {
+      app.component(comp.name, comp);
+    }
+  };
+  return main;
+}
+
+export { withInstall as w };

package/dist/es/chunk/Coex0GxM.mjs

@@ -0,0 +1,450 @@
+import { defineComponent, ref, reactive, computed, watch, onMounted, onUpdated, createElementBlock, openBlock, withModifiers, normalizeClass, unref, withDirectives, createCommentVNode, createVNode, withKeys, renderSlot, withCtx, createBlock, createSlots } from 'vue';
+import { E as ElInput } from './Dvi7RsXg.mjs';
+import { E as ElIcon } from './DMHNh_tw.mjs';
+import { ArrowDown, Minus, ArrowUp, Plus } from '@element-plus/icons-vue';
+import { f as isNumber, k as isNil, c as buildProps, d as definePropType, u as useNamespace, g as isUndefined, e as debugWarn, t as throwError, h as isString } from './E_WRn0OP.mjs';
+import { u as useSizeProp } from './CS4VKsqy.mjs';
+import { u as useAriaProps } from './C2LgraHx.mjs';
+import { U as UPDATE_MODEL_EVENT, I as INPUT_EVENT, C as CHANGE_EVENT } from './Ct6q2FXg.mjs';
+import { _ as _export_sfc, w as withInstall } from './D389hx_T.mjs';
+import { v as vRepeatClick } from './su2Zrql0.mjs';
+import { g as getEventCode, a as getEventKey, E as EVENT_CODE } from './BJS5Pdfp.mjs';
+import { u as useLocale } from './aibQ9WSZ.mjs';
+import { u as useFormItem, c as useFormSize, b as useFormDisabled } from './DZACQ9LT.mjs';
+
+const inputNumberProps = buildProps({
+  id: {
+    type: String,
+    default: void 0
+  },
+  step: {
+    type: Number,
+    default: 1
+  },
+  stepStrictly: Boolean,
+  max: {
+    type: Number,
+    default: Number.MAX_SAFE_INTEGER
+  },
+  min: {
+    type: Number,
+    default: Number.MIN_SAFE_INTEGER
+  },
+  modelValue: {
+    type: [Number, null]
+  },
+  readonly: Boolean,
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  size: useSizeProp,
+  controls: {
+    type: Boolean,
+    default: true
+  },
+  controlsPosition: {
+    type: String,
+    default: "",
+    values: ["", "right"]
+  },
+  valueOnClear: {
+    type: [String, Number, null],
+    validator: (val) => val === null || isNumber(val) || ["min", "max"].includes(val),
+    default: null
+  },
+  name: String,
+  placeholder: String,
+  precision: {
+    type: Number,
+    validator: (val) => val >= 0 && val === Number.parseInt(`${val}`, 10)
+  },
+  validateEvent: {
+    type: Boolean,
+    default: true
+  },
+  ...useAriaProps(["ariaLabel"]),
+  inputmode: {
+    type: definePropType(String),
+    default: void 0
+  },
+  align: {
+    type: definePropType(String),
+    default: "center"
+  },
+  disabledScientific: Boolean
+});
+const inputNumberEmits = {
+  [CHANGE_EVENT]: (cur, prev) => prev !== cur,
+  blur: (e) => e instanceof FocusEvent,
+  focus: (e) => e instanceof FocusEvent,
+  [INPUT_EVENT]: (val) => isNumber(val) || isNil(val),
+  [UPDATE_MODEL_EVENT]: (val) => isNumber(val) || isNil(val)
+};
+
+const __default__ = defineComponent({
+  name: "ElInputNumber"
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: inputNumberProps,
+  emits: inputNumberEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { t } = useLocale();
+    const ns = useNamespace("input-number");
+    const input = ref();
+    const data = reactive({
+      currentValue: props.modelValue,
+      userInput: null
+    });
+    const { formItem } = useFormItem();
+    const minDisabled = computed(() => isNumber(props.modelValue) && props.modelValue <= props.min);
+    const maxDisabled = computed(() => isNumber(props.modelValue) && props.modelValue >= props.max);
+    const numPrecision = computed(() => {
+      const stepPrecision = getPrecision(props.step);
+      if (!isUndefined(props.precision)) {
+        if (stepPrecision > props.precision) {
+          debugWarn("InputNumber", "precision should not be less than the decimal places of step");
+        }
+        return props.precision;
+      } else {
+        return Math.max(getPrecision(props.modelValue), stepPrecision);
+      }
+    });
+    const controlsAtRight = computed(() => {
+      return props.controls && props.controlsPosition === "right";
+    });
+    const inputNumberSize = useFormSize();
+    const inputNumberDisabled = useFormDisabled();
+    const displayValue = computed(() => {
+      if (data.userInput !== null) {
+        return data.userInput;
+      }
+      let currentValue = data.currentValue;
+      if (isNil(currentValue))
+        return "";
+      if (isNumber(currentValue)) {
+        if (Number.isNaN(currentValue))
+          return "";
+        if (!isUndefined(props.precision)) {
+          currentValue = currentValue.toFixed(props.precision);
+        }
+      }
+      return currentValue;
+    });
+    const toPrecision = (num, pre) => {
+      if (isUndefined(pre))
+        pre = numPrecision.value;
+      if (pre === 0)
+        return Math.round(num);
+      let snum = String(num);
+      const pointPos = snum.indexOf(".");
+      if (pointPos === -1)
+        return num;
+      const nums = snum.replace(".", "").split("");
+      const datum = nums[pointPos + pre];
+      if (!datum)
+        return num;
+      const length = snum.length;
+      if (snum.charAt(length - 1) === "5") {
+        snum = `${snum.slice(0, Math.max(0, length - 1))}6`;
+      }
+      return Number.parseFloat(Number(snum).toFixed(pre));
+    };
+    const getPrecision = (value) => {
+      if (isNil(value))
+        return 0;
+      const valueString = value.toString();
+      const dotPosition = valueString.indexOf(".");
+      let precision = 0;
+      if (dotPosition !== -1) {
+        precision = valueString.length - dotPosition - 1;
+      }
+      return precision;
+    };
+    const ensurePrecision = (val, coefficient = 1) => {
+      if (!isNumber(val))
+        return data.currentValue;
+      if (val >= Number.MAX_SAFE_INTEGER && coefficient === 1) {
+        debugWarn("InputNumber", "The value has reached the maximum safe integer limit.");
+        return val;
+      } else if (val <= Number.MIN_SAFE_INTEGER && coefficient === -1) {
+        debugWarn("InputNumber", "The value has reached the minimum safe integer limit.");
+        return val;
+      }
+      return toPrecision(val + props.step * coefficient);
+    };
+    const handleKeydown = (event) => {
+      const code = getEventCode(event);
+      const key = getEventKey(event);
+      if (props.disabledScientific && ["e", "E"].includes(key)) {
+        event.preventDefault();
+        return;
+      }
+      switch (code) {
+        case EVENT_CODE.up: {
+          event.preventDefault();
+          increase();
+          break;
+        }
+        case EVENT_CODE.down: {
+          event.preventDefault();
+          decrease();
+          break;
+        }
+      }
+    };
+    const increase = () => {
+      if (props.readonly || inputNumberDisabled.value || maxDisabled.value)
+        return;
+      const value = Number(displayValue.value) || 0;
+      const newVal = ensurePrecision(value);
+      setCurrentValue(newVal);
+      emit(INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const decrease = () => {
+      if (props.readonly || inputNumberDisabled.value || minDisabled.value)
+        return;
+      const value = Number(displayValue.value) || 0;
+      const newVal = ensurePrecision(value, -1);
+      setCurrentValue(newVal);
+      emit(INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const verifyValue = (value, update) => {
+      const { max, min, step, precision, stepStrictly, valueOnClear } = props;
+      if (max < min) {
+        throwError("InputNumber", "min should not be greater than max.");
+      }
+      let newVal = Number(value);
+      if (isNil(value) || Number.isNaN(newVal)) {
+        return null;
+      }
+      if (value === "") {
+        if (valueOnClear === null) {
+          return null;
+        }
+        newVal = isString(valueOnClear) ? { min, max }[valueOnClear] : valueOnClear;
+      }
+      if (stepStrictly) {
+        newVal = toPrecision(Math.round(toPrecision(newVal / step)) * step, precision);
+        if (newVal !== value) {
+          update && emit(UPDATE_MODEL_EVENT, newVal);
+        }
+      }
+      if (!isUndefined(precision)) {
+        newVal = toPrecision(newVal, precision);
+      }
+      if (newVal > max || newVal < min) {
+        newVal = newVal > max ? max : min;
+        update && emit(UPDATE_MODEL_EVENT, newVal);
+      }
+      return newVal;
+    };
+    const setCurrentValue = (value, emitChange = true) => {
+      var _a;
+      const oldVal = data.currentValue;
+      const newVal = verifyValue(value);
+      if (!emitChange) {
+        emit(UPDATE_MODEL_EVENT, newVal);
+        return;
+      }
+      data.userInput = null;
+      if (oldVal === newVal && value)
+        return;
+      emit(UPDATE_MODEL_EVENT, newVal);
+      if (oldVal !== newVal) {
+        emit(CHANGE_EVENT, newVal, oldVal);
+      }
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
+      }
+      data.currentValue = newVal;
+    };
+    const handleInput = (value) => {
+      data.userInput = value;
+      const newVal = value === "" ? null : Number(value);
+      emit(INPUT_EVENT, newVal);
+      setCurrentValue(newVal, false);
+    };
+    const handleInputChange = (value) => {
+      const newVal = value !== "" ? Number(value) : "";
+      if (isNumber(newVal) && !Number.isNaN(newVal) || value === "") {
+        setCurrentValue(newVal);
+      }
+      setCurrentValueToModelValue();
+      data.userInput = null;
+    };
+    const focus = () => {
+      var _a, _b;
+      (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+    };
+    const blur = () => {
+      var _a, _b;
+      (_b = (_a = input.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
+    };
+    const handleFocus = (event) => {
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      var _a, _b;
+      data.userInput = null;
+      if (data.currentValue === null && ((_a = input.value) == null ? void 0 : _a.input)) {
+        input.value.input.value = "";
+      }
+      emit("blur", event);
+      if (props.validateEvent) {
+        (_b = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _b.call(formItem, "blur").catch((err) => debugWarn(err));
+      }
+    };
+    const setCurrentValueToModelValue = () => {
+      if (data.currentValue !== props.modelValue) {
+        data.currentValue = props.modelValue;
+      }
+    };
+    const handleWheel = (e) => {
+      if (document.activeElement === e.target)
+        e.preventDefault();
+    };
+    watch(() => props.modelValue, (value, oldValue) => {
+      const newValue = verifyValue(value, true);
+      if (data.userInput === null && newValue !== oldValue) {
+        data.currentValue = newValue;
+      }
+    }, { immediate: true });
+    watch(() => props.precision, () => {
+      data.currentValue = verifyValue(props.modelValue);
+    });
+    onMounted(() => {
+      var _a;
+      const { min, max, modelValue } = props;
+      const innerInput = (_a = input.value) == null ? void 0 : _a.input;
+      innerInput.setAttribute("role", "spinbutton");
+      if (Number.isFinite(max)) {
+        innerInput.setAttribute("aria-valuemax", String(max));
+      } else {
+        innerInput.removeAttribute("aria-valuemax");
+      }
+      if (Number.isFinite(min)) {
+        innerInput.setAttribute("aria-valuemin", String(min));
+      } else {
+        innerInput.removeAttribute("aria-valuemin");
+      }
+      innerInput.setAttribute("aria-valuenow", data.currentValue || data.currentValue === 0 ? String(data.currentValue) : "");
+      innerInput.setAttribute("aria-disabled", String(inputNumberDisabled.value));
+      if (!isNumber(modelValue) && modelValue != null) {
+        let val = Number(modelValue);
+        if (Number.isNaN(val)) {
+          val = null;
+        }
+        emit(UPDATE_MODEL_EVENT, val);
+      }
+      innerInput.addEventListener("wheel", handleWheel, { passive: false });
+    });
+    onUpdated(() => {
+      var _a, _b;
+      const innerInput = (_a = input.value) == null ? void 0 : _a.input;
+      innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${(_b = data.currentValue) != null ? _b : ""}`);
+    });
+    expose({
+      focus,
+      blur
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          unref(ns).b(),
+          unref(ns).m(unref(inputNumberSize)),
+          unref(ns).is("disabled", unref(inputNumberDisabled)),
+          unref(ns).is("without-controls", !_ctx.controls),
+          unref(ns).is("controls-right", unref(controlsAtRight)),
+          unref(ns).is(_ctx.align, !!_ctx.align)
+        ]),
+        onDragstart: withModifiers(() => {
+        }, ["prevent"])
+      }, [
+        _ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
+          key: 0,
+          role: "button",
+          "aria-label": unref(t)("el.inputNumber.decrease"),
+          class: normalizeClass([unref(ns).e("decrease"), unref(ns).is("disabled", unref(minDisabled))]),
+          onKeydown: withKeys(decrease, ["enter"])
+        }, [
+          renderSlot(_ctx.$slots, "decrease-icon", {}, () => [
+            createVNode(unref(ElIcon), null, {
+              default: withCtx(() => [
+                unref(controlsAtRight) ? (openBlock(), createBlock(unref(ArrowDown), { key: 0 })) : (openBlock(), createBlock(unref(Minus), { key: 1 }))
+              ]),
+              _: 1
+            })
+          ])
+        ], 42, ["aria-label", "onKeydown"])), [
+          [unref(vRepeatClick), decrease]
+        ]) : createCommentVNode("v-if", true),
+        _ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
+          key: 1,
+          role: "button",
+          "aria-label": unref(t)("el.inputNumber.increase"),
+          class: normalizeClass([unref(ns).e("increase"), unref(ns).is("disabled", unref(maxDisabled))]),
+          onKeydown: withKeys(increase, ["enter"])
+        }, [
+          renderSlot(_ctx.$slots, "increase-icon", {}, () => [
+            createVNode(unref(ElIcon), null, {
+              default: withCtx(() => [
+                unref(controlsAtRight) ? (openBlock(), createBlock(unref(ArrowUp), { key: 0 })) : (openBlock(), createBlock(unref(Plus), { key: 1 }))
+              ]),
+              _: 1
+            })
+          ])
+        ], 42, ["aria-label", "onKeydown"])), [
+          [unref(vRepeatClick), increase]
+        ]) : createCommentVNode("v-if", true),
+        createVNode(unref(ElInput), {
+          id: _ctx.id,
+          ref_key: "input",
+          ref: input,
+          type: "number",
+          step: _ctx.step,
+          "model-value": unref(displayValue),
+          placeholder: _ctx.placeholder,
+          readonly: _ctx.readonly,
+          disabled: unref(inputNumberDisabled),
+          size: unref(inputNumberSize),
+          max: _ctx.max,
+          min: _ctx.min,
+          name: _ctx.name,
+          "aria-label": _ctx.ariaLabel,
+          "validate-event": false,
+          inputmode: _ctx.inputmode,
+          onKeydown: handleKeydown,
+          onBlur: handleBlur,
+          onFocus: handleFocus,
+          onInput: handleInput,
+          onChange: handleInputChange
+        }, createSlots({
+          _: 2
+        }, [
+          _ctx.$slots.prefix ? {
+            name: "prefix",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "prefix")
+            ])
+          } : void 0,
+          _ctx.$slots.suffix ? {
+            name: "suffix",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "suffix")
+            ])
+          } : void 0
+        ]), 1032, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "inputmode"])
+      ], 42, ["onDragstart"]);
+    };
+  }
+});
+var InputNumber = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "input-number.vue"]]);
+
+const ElInputNumber = withInstall(InputNumber);
+
+export { ElInputNumber as E };

package/dist/es/chunk/Ct6q2FXg.mjs

@@ -0,0 +1,5 @@
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const CHANGE_EVENT = "change";
+const INPUT_EVENT = "input";
+
+export { CHANGE_EVENT as C, INPUT_EVENT as I, UPDATE_MODEL_EVENT as U };

package/dist/es/chunk/CyxEcbcy.mjs

@@ -0,0 +1,29 @@
+import { b as baseClone } from './nWBcrYxV.mjs';
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/**
+ * This method is like `_.clone` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.clone
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var deep = _.cloneDeep(objects);
+ * console.log(deep[0] === objects[0]);
+ * // => false
+ */
+function cloneDeep(value) {
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+
+export { cloneDeep as c };