clayui-date-picker 3.165.0

package/lib/cjs/Hooks.js

@@ -0,0 +1,298 @@
+"use strict";
+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);
+var Hooks_exports = {};
+__export(Hooks_exports, {
+  useCalendarNavigation: () => useCalendarNavigation,
+  useCurrentTime: () => useCurrentTime,
+  useDaysSelected: () => useDaysSelected,
+  useWeeks: () => useWeeks
+});
+module.exports = __toCommonJS(Hooks_exports);
+var import_shared = require("@clayui/shared");
+var import_react = require("react");
+var import_Helpers = require("./Helpers");
+function normalizeTime(date) {
+  return (0, import_Helpers.setDate)(date, { hours: 12, milliseconds: 0, minutes: 0, seconds: 0 });
+}
+function useDaysSelected(defaultDays) {
+  const [daysSelected, set] = (0, import_react.useState)(defaultDays);
+  const setDaysSelected = (0, import_react.useCallback)(([start, end]) => {
+    if (start === end) {
+      const date = normalizeTime(start);
+      set([date, date]);
+    } else {
+      set([normalizeTime(start), normalizeTime(end)]);
+    }
+  }, []);
+  return [daysSelected, setDaysSelected];
+}
+function useWeeks(currentMonth, firstDayOfWeek) {
+  const [weeks, set] = (0, import_react.useState)(
+    () => getWeekArray(currentMonth, firstDayOfWeek)
+  );
+  const setWeeks = (0, import_react.useCallback)(
+    (value) => set(getWeekArray(value, firstDayOfWeek)),
+    [firstDayOfWeek]
+  );
+  return [weeks, setWeeks];
+}
+function useCurrentTime(defaultTime, use12Hours) {
+  const [currentTime, set] = (0, import_react.useState)(defaultTime);
+  const setCurrentTime = (0, import_react.useCallback)(
+    (hours, minutes, ampm) => {
+      const date = (0, import_Helpers.setDate)(/* @__PURE__ */ new Date(), { hours, minutes });
+      if (typeof hours !== "string") {
+        if (use12Hours) {
+          hours = (0, import_Helpers.formatDate)(date, "hh");
+        } else {
+          hours = (0, import_Helpers.formatDate)(date, "HH");
+        }
+      }
+      if (typeof minutes !== "string") {
+        minutes = (0, import_Helpers.formatDate)(date, "mm");
+      }
+      const value = ampm ? `${hours}:${minutes} ${ampm}` : `${hours}:${minutes}`;
+      set(value);
+      return value;
+    },
+    [use12Hours]
+  );
+  return [currentTime, setCurrentTime];
+}
+function useCalendarNavigation({
+  daysSelected,
+  isOpen,
+  onChangeMonth,
+  weeks
+}) {
+  const [lastItemFocused, setLastItemFocused] = (0, import_react.useState)(null);
+  const gridRef = (0, import_react.useRef)(null);
+  const lastKeyPressedRef = (0, import_react.useRef)("");
+  const hasNextFocusRef = (0, import_react.useRef)(false);
+  const focusNext = (0, import_react.useCallback)((day) => {
+    if (!gridRef.current) {
+      return;
+    }
+    const nextFocusElement = gridRef.current.querySelector(
+      `button[aria-label="${(0, import_Helpers.setDate)(day.date, {
+        hours: 12,
+        milliseconds: 0,
+        minutes: 0,
+        seconds: 0
+      }).toDateString()}"]`
+    );
+    if (nextFocusElement) {
+      nextFocusElement.focus();
+      setLastItemFocused(String(day.date.getDate()));
+    }
+  }, []);
+  const onKeyDown = (0, import_react.useCallback)(
+    (event) => {
+      switch (event.key) {
+        case import_shared.Keys.Down:
+        case import_shared.Keys.Up:
+        case import_shared.Keys.Right:
+        case import_shared.Keys.Left: {
+          event.preventDefault();
+          const currentRowPosition = Number(
+            document.activeElement.closest("[role=row]").getAttribute("data-index")
+          );
+          const position = Number(
+            document.activeElement.getAttribute("data-index")
+          );
+          const currentRow = weeks[currentRowPosition];
+          let nextFocus = null;
+          switch (event.key) {
+            case import_shared.Keys.Right:
+            case import_shared.Keys.Left: {
+              nextFocus = currentRow[event.key === import_shared.Keys.Left ? position - 1 : position + 1];
+              if (!nextFocus) {
+                nextFocus = weeks[event.key === import_shared.Keys.Left ? currentRowPosition - 1 : currentRowPosition + 1]?.[event.key === import_shared.Keys.Left ? currentRow.length - 1 : 0];
+              }
+              break;
+            }
+            case import_shared.Keys.Up:
+            case import_shared.Keys.Down: {
+              nextFocus = weeks[event.key === import_shared.Keys.Up ? currentRowPosition - 1 : currentRowPosition + 1]?.[position];
+              break;
+            }
+            default:
+              break;
+          }
+          if (nextFocus && !nextFocus.nextMonth && !nextFocus.previousMonth) {
+            focusNext(nextFocus);
+          } else {
+            onChangeMonth(
+              event.key === import_shared.Keys.Left || event.key === import_shared.Keys.Up ? -1 : 1
+            );
+            lastKeyPressedRef.current = event.key;
+            hasNextFocusRef.current = true;
+          }
+          break;
+        }
+        case import_shared.Keys.End:
+        case import_shared.Keys.Home: {
+          event.preventDefault();
+          const grid = event.currentTarget.querySelectorAll(
+            "button:not(.previous-month-date):not(.next-month-date)"
+          );
+          const day = grid[event.key === import_shared.Keys.Home ? 0 : grid.length - 1];
+          if (day) {
+            day.focus();
+            setLastItemFocused(day.innerText);
+          }
+          break;
+        }
+        case "PageDown":
+        case "PageUp": {
+          event.preventDefault();
+          const value = event.key === "PageUp" ? -1 : 1;
+          if (event.shiftKey) {
+            onChangeMonth(0, value);
+          } else {
+            onChangeMonth(value);
+          }
+          lastKeyPressedRef.current = event.key;
+          hasNextFocusRef.current = true;
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    [weeks]
+  );
+  const onFocus = (0, import_react.useCallback)((event) => {
+    setLastItemFocused(event.target.innerText);
+  }, []);
+  const isFocused = (0, import_react.useCallback)(
+    (day) => {
+      return !day.nextMonth && !day.previousMonth && (lastItemFocused === String(day.date.getDate()) || lastItemFocused === null && day.date.toDateString() === daysSelected[0].toDateString());
+    },
+    [lastItemFocused, daysSelected]
+  );
+  (0, import_react.useEffect)(() => {
+    if (gridRef.current && isOpen) {
+      focusNext({ date: daysSelected[0] });
+    }
+  }, [daysSelected]);
+  (0, import_react.useEffect)(() => {
+    if (gridRef.current) {
+      if (isOpen) {
+        const focusNext2 = gridRef.current.querySelector(
+          'button:not([tabindex="-1"])'
+        );
+        if (focusNext2) {
+          focusNext2.focus();
+        }
+      } else {
+        setLastItemFocused(null);
+      }
+    }
+  }, [isOpen]);
+  (0, import_react.useEffect)(() => {
+    if (hasNextFocusRef.current && gridRef.current) {
+      hasNextFocusRef.current = false;
+      const position = Number(
+        document.activeElement.getAttribute("data-index")
+      );
+      const row = weeks[lastKeyPressedRef.current === import_shared.Keys.Left || lastKeyPressedRef.current === import_shared.Keys.Up ? weeks.length - 1 : 0];
+      switch (lastKeyPressedRef.current) {
+        case import_shared.Keys.Right:
+        case import_shared.Keys.Left: {
+          const newRow = row.filter(
+            (value) => !value.nextMonth && !value.previousMonth
+          );
+          focusNext(
+            newRow[lastKeyPressedRef.current === import_shared.Keys.Left ? newRow.length - 1 : 0]
+          );
+          break;
+        }
+        case import_shared.Keys.Down:
+        case import_shared.Keys.Up: {
+          let nextFocus = row.map(
+            (value) => !value.nextMonth && !value.previousMonth ? value : null
+          )[position];
+          if (!nextFocus) {
+            nextFocus = weeks[lastKeyPressedRef.current === import_shared.Keys.Up ? weeks.length - 2 : 1][position];
+          }
+          focusNext(nextFocus);
+          break;
+        }
+        case "PageDown":
+        case "PageUp": {
+          const focusNext2 = gridRef.current.querySelector(
+            'button:not([tabindex="-1"])'
+          );
+          if (focusNext2) {
+            focusNext2.focus();
+          }
+          break;
+        }
+        default:
+          break;
+      }
+      lastKeyPressedRef.current = "";
+    }
+  }, [weeks]);
+  const gridProps = { onFocus, onKeyDown, ref: gridRef };
+  return {
+    gridProps,
+    isFocused
+  };
+}
+function getDaysInMonth(d) {
+  const firstDayOfMonth = new Date(d.getFullYear(), d.getMonth(), 1, 12);
+  firstDayOfMonth.setMonth(firstDayOfMonth.getMonth() + 1);
+  firstDayOfMonth.setDate(firstDayOfMonth.getDate() - 1);
+  return firstDayOfMonth.getDate();
+}
+function getWeekArray(d, firstDayOfWeek = 0) {
+  const daysInMonth = getDaysInMonth(d);
+  const dayArray = [];
+  let week = [];
+  const weekArray = [];
+  for (let i = 1; i <= daysInMonth; i += 1) {
+    const genDay = new Date(d.getFullYear(), d.getMonth(), i, 12);
+    dayArray.push({ date: genDay });
+  }
+  dayArray.forEach((day) => {
+    if (!!week.length && day.date.getDay() === firstDayOfWeek) {
+      weekArray.push(week);
+      week = [];
+    }
+    week.push(day);
+    if (dayArray.indexOf(day) === dayArray.length - 1) {
+      weekArray.push(week);
+    }
+  });
+  const firstWeek = weekArray[0];
+  for (let i = 7 - firstWeek.length; i > 0; i -= 1) {
+    const outsideDate = (0, import_Helpers.clone)(firstWeek[0].date);
+    outsideDate.setDate(firstWeek[0].date.getDate() - 1);
+    firstWeek.unshift({ date: outsideDate, previousMonth: true });
+  }
+  const lastWeek = weekArray[weekArray.length - 1];
+  for (let i = lastWeek.length; i < 7; i += 1) {
+    const outsideDate = (0, import_Helpers.clone)(lastWeek[lastWeek.length - 1].date);
+    outsideDate.setDate(lastWeek[lastWeek.length - 1].date.getDate() + 1);
+    lastWeek.push({ date: outsideDate, nextMonth: true });
+  }
+  return weekArray;
+}

package/lib/cjs/InputDate.js

@@ -0,0 +1,58 @@
+"use strict";
+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);
+var InputDate_exports = {};
+__export(InputDate_exports, {
+  default: () => InputDate_default
+});
+module.exports = __toCommonJS(InputDate_exports);
+var import_form = require("@clayui/form");
+var import_react = __toESM(require("react"));
+const ClayDatePickerInputDate = import_react.default.forwardRef(
+  ({
+    ariaLabel,
+    inputName = "datePicker",
+    useNative = false,
+    value = "",
+    ...otherProps
+  }, ref) => {
+    return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement("input", { name: inputName, type: "hidden", value }), /* @__PURE__ */ import_react.default.createElement(
+      import_form.ClayInput,
+      {
+        ...otherProps,
+        "aria-label": ariaLabel,
+        insetAfter: !useNative,
+        ref,
+        type: useNative ? "date" : "text",
+        value
+      }
+    ));
+  }
+);
+ClayDatePickerInputDate.displayName = "ClayDatePickerInputDate";
+var InputDate_default = ClayDatePickerInputDate;

package/lib/cjs/Select.js

@@ -0,0 +1,56 @@
+"use strict";
+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);
+var Select_exports = {};
+__export(Select_exports, {
+  default: () => Select_default
+});
+module.exports = __toCommonJS(Select_exports);
+var import_react = __toESM(require("react"));
+const ClayDatePickerSelect = import_react.default.forwardRef(
+  ({ options, testId, ...otherProps }, ref) => /* @__PURE__ */ import_react.default.createElement(
+    "select",
+    {
+      ...otherProps,
+      className: "form-control form-control-sm",
+      "data-testid": testId,
+      ref
+    },
+    options.map((option, index) => /* @__PURE__ */ import_react.default.createElement(
+      "option",
+      {
+        key: index,
+        selected: option.selected ? true : void 0,
+        value: option.value
+      },
+      option.label
+    ))
+  )
+);
+ClayDatePickerSelect.displayName = "ClayDatePickerSelect";
+var Select_default = ClayDatePickerSelect;

package/lib/cjs/TimePicker.js

@@ -0,0 +1,82 @@
+"use strict";
+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);
+var TimePicker_exports = {};
+__export(TimePicker_exports, {
+  default: () => TimePicker_default
+});
+module.exports = __toCommonJS(TimePicker_exports);
+var import_time_picker = __toESM(require("@clayui/time-picker"));
+var import_react = __toESM(require("react"));
+const DEFAULT_VALUE = "--";
+function ClayDatePickerTimePicker({
+  config,
+  currentTime,
+  disabled,
+  onTimeChange,
+  spritemap,
+  timezone,
+  use12Hours
+}) {
+  const [values, setValues] = import_react.default.useState({
+    ampm: DEFAULT_VALUE,
+    hours: DEFAULT_VALUE,
+    minutes: DEFAULT_VALUE
+  });
+  const handleOnChange = (values2) => {
+    const hours = values2.hours === DEFAULT_VALUE ? DEFAULT_VALUE : Number(values2.hours);
+    const minutes = values2.minutes === DEFAULT_VALUE ? DEFAULT_VALUE : Number(values2.minutes);
+    const ampm = values2.ampm ? values2.ampm : DEFAULT_VALUE;
+    setValues(values2);
+    onTimeChange(hours, minutes, ampm);
+  };
+  import_react.default.useEffect(() => {
+    const [hours, minutesAndAmpm] = currentTime.split(":");
+    const [minutes, ampm] = minutesAndAmpm.split(" ");
+    setValues((prevValues) => ({
+      ...prevValues,
+      ampm,
+      hours: String(hours),
+      minutes: String(minutes)
+    }));
+  }, [currentTime, use12Hours]);
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: "time-picker" }, /* @__PURE__ */ import_react.default.createElement(
+    import_time_picker.default,
+    {
+      config,
+      disabled,
+      icon: true,
+      onInputChange: handleOnChange,
+      spritemap,
+      timezone,
+      use12Hours,
+      values
+    }
+  ));
+}
+var TimePicker_default = ClayDatePickerTimePicker;

package/lib/cjs/Weekday.js

@@ -0,0 +1,38 @@
+"use strict";
+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);
+var Weekday_exports = {};
+__export(Weekday_exports, {
+  default: () => Weekday_default
+});
+module.exports = __toCommonJS(Weekday_exports);
+var import_react = __toESM(require("react"));
+function ClayDatePickerWeekday({ weekday }) {
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: "date-picker-col" }, /* @__PURE__ */ import_react.default.createElement("div", { className: "date-picker-calendar-item date-picker-day" }, /* @__PURE__ */ import_react.default.createElement("abbr", null, weekday)));
+}
+var Weekday_default = ClayDatePickerWeekday;

package/lib/cjs/WeekdayHeader.js

@@ -0,0 +1,57 @@
+"use strict";
+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);
+var WeekdayHeader_exports = {};
+__export(WeekdayHeader_exports, {
+  default: () => WeekdayHeader_default
+});
+module.exports = __toCommonJS(WeekdayHeader_exports);
+var import_react = __toESM(require("react"));
+function ClayDatePickerWeekdayHeader({
+  children,
+  firstDayOfWeek = 0,
+  weekdaysShort
+}) {
+  return /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: "date-picker-days-row date-picker-row",
+      role: "presentation"
+    },
+    weekdaysShort.map((_weekday, index) => {
+      return import_react.default.Children.only(
+        children({
+          key: index,
+          weekday: weekdaysShort[(index + firstDayOfWeek) % 7]
+        })
+      );
+    })
+  );
+}
+var WeekdayHeader_default = ClayDatePickerWeekdayHeader;