@unicom-cloud/utils 0.1.23 → 0.1.24

package/tree/search/index.js

@@ -1,16 +1,17 @@
-import "../../is/index.js";
-import S from "lodash/isArray";
-import B from "lodash/isObjectLike";
-import p from "lodash/isString";
-import C from "lodash/isNumber";
-import K from "lodash/isFunction";
-import L from "lodash/isRegExp";
-function j(i, a, m, w) {
-  return a && i ? { shouldExit: !0, newMatch: !0 } : m && !i ? { shouldExit: !0, newMatch: !1 } : { shouldExit: !1, newMatch: w || i };
+/* 2025-10-28 09:57:10 */
+import E from "lodash/isArray";
+import B from "lodash/isFunction";
+import C from "lodash/isNil";
+import K from "lodash/isNumber";
+import L from "lodash/isObjectLike";
+import j from "lodash/isRegExp";
+import f from "lodash/isString";
+function k(n, u, m, w) {
+  return u && n ? { shouldExit: !0, newMatch: !0 } : m && !n ? { shouldExit: !0, newMatch: !1 } : { shouldExit: !1, newMatch: w || n };
 }
-function P(i, a, m = {}) {
-  if (!S(i)) throw new TypeError("参数 treeData 必须是一个数组");
-  if (!B(a)) throw new TypeError("参数 searchCondition 必须是一个对象");
+function P(n, u, m = {}) {
+  if (C(n) || !E(n)) return null;
+  if (!L(u)) throw new TypeError("参数 searchCondition 必须是一个对象");
   const w = {
     strategy: "BFS",
     childrenKey: "children",
@@ -26,68 +27,60 @@ function P(i, a, m = {}) {
     ...m
     // 用户配置覆盖默认值
   }, {
-    strategy: E,
-    childrenKey: u,
-    strict: R,
-    fuzzyMatch: b,
+    strategy: S,
+    childrenKey: a,
+    strict: v,
+    fuzzyMatch: R,
     returnAllMatches: M,
-    caseSensitive: v,
+    caseSensitive: b,
     allowEmptyString: z,
     matchMode: T,
     returnTree: g,
     returnTreeMaxDepth: d
-  } = w, D = T === "OR", x = T === "AND", y = E === "BFS";
-  if (!(y || E === "DFS")) throw new Error('配置 strategy 必须是 "BFS" 或 "DFS"');
-  if (!(D || x)) throw new Error('配置 matchMode 必须是 "AND" 或 "OR"');
-  if (!p(u)) throw new TypeError("配置 childrenKey 必须是字符串");
+  } = w, x = T === "OR", A = T === "AND", y = S === "BFS";
+  if (!(y || S === "DFS")) throw new Error('配置 strategy 必须是 "BFS" 或 "DFS"');
+  if (!(x || A)) throw new Error('配置 matchMode 必须是 "AND" 或 "OR"');
+  if (!f(a)) throw new TypeError("配置 childrenKey 必须是字符串");
   if (g) {
     if (!M) throw new Error(
       "当 returnTree 为 true 时，returnAllMatches 也必须为 true"
     );
-    if (!(C(d) && d > -1)) throw new TypeError("配置 returnTreeMaxDepth 必须是一个非负整数");
+    if (!(K(d) && d > -1)) throw new TypeError("配置 returnTreeMaxDepth 必须是一个非负整数");
   }
-  const h = [...i], A = [], F = Object.entries(a);
-  if (F.length) {
+  const h = [...n], F = [], D = Object.entries(u);
+  if (D.length) {
     const N = (r) => {
       let s = !1;
-      for (const [n, e] of F) {
-        const t = r[n];
-        if (e === "" && !z)
+      for (const [i, c] of D) {
+        let e = c, t = r[i];
+        if (b || (f(e) && (e = e.toLowerCase()), f(t) && (t = t.toLowerCase())), e === "" && !z)
           continue;
         let o = !1;
-        if (K(e))
-          o = !!e(t, r);
-        else if (L(e) && p(t))
-          o = t ? e.test(t) : !1;
-        else if (b && p(e) && p(t)) {
-          let l = e, c = t;
-          v || (l = e.toLowerCase(), c = t.toLowerCase()), o = c.includes(l);
-        } else
-          o = R ? t === e : t == e;
-        const f = j(o, D, x, s);
-        if (f.shouldExit)
-          return f.newMatch;
-        s = f.newMatch;
+        B(e) ? o = !!e(t, r) : j(e) && f(t) ? o = t ? e.test(t) : !1 : R && f(e) && f(t) ? o = t.includes(e) : o = v ? t === e : t == e;
+        const l = k(o, x, A, s);
+        if (l.shouldExit)
+          return l.newMatch;
+        s = l.newMatch;
       }
       return s;
     };
     if (g) {
-      const r = (n, e = 1) => {
-        const t = d > 0 && e > d, o = !t && N(n), f = t ? void 0 : n[u], l = [];
-        if (S(f))
-          for (const c of f) {
-            const O = r(c, e + 1);
+      const r = (i, c = 1) => {
+        const e = d > 0 && c > d, t = !e && N(i), o = e ? void 0 : i[a], l = [];
+        if (E(o))
+          for (const p of o) {
+            const O = r(p, c + 1);
             O && l.push(O);
           }
-        if (o || l.length > 0) {
-          const c = { ...n };
-          return l.length > 0 && (c[u] = l), c;
+        if (t || l.length > 0) {
+          const p = { ...i };
+          return l.length > 0 && (p[a] = l), p;
         }
         return null;
       }, s = [];
-      for (const n of i) {
-        const e = r(n, 1);
-        e && s.push(e);
+      for (const i of n) {
+        const c = r(i, 1);
+        c && s.push(c);
       }
       return s;
     } else
@@ -96,19 +89,19 @@ function P(i, a, m = {}) {
         if (!r) continue;
         if (N(r))
           if (M)
-            A.push(r);
+            F.push(r);
           else
             return r;
-        const s = r[u];
-        if (S(s))
+        const s = r[a];
+        if (E(s))
           if (y)
             h.push(...s);
           else
-            for (let n = s.length - 1; n >= 0; n--)
-              h.push(s[n]);
+            for (let i = s.length - 1; i >= 0; i--)
+              h.push(s[i]);
       }
   }
-  return M ? A : null;
+  return M ? F : null;
 }
 export {
   P as default

package/tree.js

@@ -1,13 +1,17 @@
+/* 2025-10-28 09:57:10 */
+import "lodash/castArray";
+import "lodash/isArray";
+import "lodash/isUndefined";
 import { default as a } from "./tree/search/index.js";
-import { getItemBy as y, findNodeBy as m, getChildWithParentBy as B, getItemBy as g, getItemBy2 as o, getItemBy3 as I, getItemByID as d, getLabelFromDictionaryByValue as f } from "./tree/index.js";
+import { getItemBy as i, findNodeBy as B, getChildWithParentBy as d, getItemBy as g, getItemBy2 as f, findNodeBy as I, getItemByID as l, getLabelFromDictionaryByValue as p } from "./tree/index.js";
 export {
-  y as default,
-  m as findNodeBy,
-  B as getChildWithParentBy,
+  i as default,
+  B as findNodeBy,
+  d as getChildWithParentBy,
   g as getItemBy,
-  o as getItemBy2,
+  f as getItemBy2,
   I as getItemBy3,
-  d as getItemByID,
-  f as getLabelFromDictionaryByValue,
+  l as getItemByID,
+  p as getLabelFromDictionaryByValue,
   a as searchTree
 };

package/types/date/convertToDuration.d.ts

@@ -0,0 +1,2 @@
+export default convertToDurationBasedOnTimeUnits;
+declare function convertToDurationBasedOnTimeUnits(duration: any, unit: any): string;

package/types/date/index.d.ts

@@ -1,4 +1,4 @@
-export function convertToDurationBasedOnTimeUnits(duration: any, unit: any): string;
 export function dateFormat(date: any, template: any): any;
 export { default as convertTime } from "./convertTime";
-export { dateFormat as dayjsFormat };
+import convertToDurationBasedOnTimeUnits from './convertToDuration';
+export { convertToDurationBasedOnTimeUnits, dateFormat as dayjsFormat };

package/types/dom-helpers/activeElement.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the actively focused element safely.
+ *
+ * @param doc the document to check
+ */
+export default function activeElement(doc?: Document): Element | null;

package/types/dom-helpers/addClass.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Adds a CSS class to a given element.
+ *
+ * @param element the element
+ * @param className the CSS class name
+ */
+export default function addClass(element: Element | SVGElement, className: string): void;

package/types/dom-helpers/addEventListener.d.ts

@@ -0,0 +1,16 @@
+export declare let optionsSupported: boolean;
+export declare let onceSupported: boolean;
+export type EventHandler<K extends keyof HTMLElementEventMap> = (this: HTMLElement, event: HTMLElementEventMap[K]) => any;
+export type TaggedEventHandler<K extends keyof HTMLElementEventMap> = EventHandler<K> & {
+    __once?: EventHandler<K>;
+};
+/**
+ * An `addEventListener` ponyfill, supports the `once` option
+ *
+ * @param node the element
+ * @param eventName the event name
+ * @param handle the handler
+ * @param options event options
+ */
+declare function addEventListener<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: TaggedEventHandler<K>, options?: boolean | AddEventListenerOptions): void;
+export default addEventListener;

package/types/dom-helpers/animate.d.ts

@@ -0,0 +1,19 @@
+import { EventHandler } from './addEventListener';
+import { TransformValue } from './isTransform';
+import { Property } from './types';
+type AnimateProperties = Record<Property | TransformValue, string>;
+interface Options {
+    node: HTMLElement;
+    properties: AnimateProperties;
+    duration?: number;
+    easing?: string;
+    callback?: EventHandler<'transitionend'>;
+}
+interface Cancel {
+    cancel(): void;
+}
+declare function animate(options: Options): Cancel;
+declare function animate(node: HTMLElement, properties: AnimateProperties, duration: number): Cancel;
+declare function animate(node: HTMLElement, properties: AnimateProperties, duration: number, callback: EventHandler<'transitionend'>): Cancel;
+declare function animate(node: HTMLElement, properties: AnimateProperties, duration: number, easing: string, callback: EventHandler<'transitionend'>): Cancel;
+export default animate;

package/types/dom-helpers/animationFrame.d.ts

@@ -0,0 +1,2 @@
+export declare const cancel: (id: number) => void;
+export declare const request: typeof requestAnimationFrame;

package/types/dom-helpers/attribute.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets or sets an attribute of a given element.
+ *
+ * @param node the element
+ * @param attr the attribute to get or set
+ * @param val the attribute value
+ */
+export default function attribute(node: Element | null, attr: string, val?: string | boolean | null): string | null | undefined;

package/types/dom-helpers/camelize.d.ts

@@ -0,0 +1 @@
+export default function camelize(string: string): string;

package/types/dom-helpers/camelizeStyle.d.ts

@@ -0,0 +1,2 @@
+import { CamelProperty, Property } from './types';
+export default function camelizeStyleName<T extends string = Property>(string: T): CamelProperty;

package/types/dom-helpers/canUseDOM.d.ts

@@ -0,0 +1,2 @@
+declare const _default: boolean;
+export default _default;

package/types/dom-helpers/childElements.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Collects all child elements of an element.
+ *
+ * @param node the element
+ */
+export default function childElements(node: Element | null): Element[];

package/types/dom-helpers/childNodes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Collects all child nodes of an element.
+ *
+ * @param node the node
+ */
+export default function childNodes(node: Element | null): Node[];

package/types/dom-helpers/clear.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Removes all child nodes from a given node.
+ *
+ * @param node the node to clear
+ */
+export default function clear(node: Node | null): Node | null;

package/types/dom-helpers/closest.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the closest parent element that matches a given selector.
+ *
+ * @param node the reference element
+ * @param selector the selector to match
+ * @param stopAt stop traversing when this element is found
+ */
+export default function closest(node: Element, selector: string, stopAt?: Element): Element | null;

package/types/dom-helpers/collectElements.d.ts

@@ -0,0 +1,3 @@
+type TraverseDirection = 'parentElement' | 'previousElementSibling' | 'nextElementSibling';
+export default function collectElements(node: Element | null, direction: TraverseDirection): Element[];
+export {};

package/types/dom-helpers/collectSiblings.d.ts

@@ -0,0 +1 @@
+export default function collectSiblings(node: Element | null, refNode?: Element | null, selector?: string | null): Element[];

package/types/dom-helpers/contains.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if an element contains another given element.
+ *
+ * @param context the context element
+ * @param node the element to check
+ */
+export default function contains(context: Element, node: Element): boolean | undefined;

package/types/dom-helpers/css.d.ts

@@ -0,0 +1,3 @@
+import { Property } from './types';
+declare function style<T extends Property>(node: HTMLElement, property: T | Record<Property, string | number>): string | undefined;
+export default style;

package/types/dom-helpers/filterEventHandler.d.ts

@@ -0,0 +1,2 @@
+import { EventHandler } from './addEventListener';
+export default function filterEvents<K extends keyof HTMLElementEventMap>(selector: string, handler: EventHandler<K>): EventHandler<K>;

package/types/dom-helpers/getComputedStyle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns one or all computed style properties of an element.
+ *
+ * @param node the element
+ * @param psuedoElement the style property
+ */
+export default function getComputedStyle(node: HTMLElement, psuedoElement?: string): CSSStyleDeclaration;

package/types/dom-helpers/getScrollAccessor.d.ts

@@ -0,0 +1 @@
+export default function getscrollAccessor(offset: 'pageXOffset' | 'pageYOffset'): (node: Element, val?: number) => number | undefined;

package/types/dom-helpers/hasClass.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a given element has a CSS class.
+ *
+ * @param element the element
+ * @param className the CSS class name
+ */
+export default function hasClass(element: Element | SVGElement, className: string): boolean;

package/types/dom-helpers/height.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the height of a given element.
+ *
+ * @param node the element
+ * @param client whether to use `clientHeight` if possible
+ */
+export default function height(node: HTMLElement, client?: boolean): number;

package/types/dom-helpers/hyphenate.d.ts

@@ -0,0 +1 @@
+export default function hyphenate(string: string): string;

package/types/dom-helpers/hyphenateStyle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2013-2014, Facebook, Inc.
+ * All rights reserved.
+ * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js
+ */
+import { Property } from './types';
+export default function hyphenateStyleName(string: Property): Property;

package/types/dom-helpers/index.d.ts

@@ -0,0 +1,93 @@
+import activeElement from './activeElement';
+import addClass from './addClass';
+import addEventListener from './addEventListener';
+import animate from './animate';
+import { cancel as cancelAnimationFrame, request as requestAnimationFrame } from './animationFrame';
+import attribute from './attribute';
+import childElements from './childElements';
+import childNodes from './childNodes';
+import clear from './clear';
+import closest from './closest';
+import contains from './contains';
+import style from './css';
+import filter from './filterEventHandler';
+import getComputedStyle from './getComputedStyle';
+import hasClass from './hasClass';
+import height from './height';
+import insertAfter from './insertAfter';
+import isInput from './isInput';
+import isVisible from './isVisible';
+import listen from './listen';
+import matches from './matches';
+import nextUntil from './nextUntil';
+import offset from './offset';
+import offsetParent from './offsetParent';
+import ownerDocument from './ownerDocument';
+import ownerWindow from './ownerWindow';
+import parents from './parents';
+import position from './position';
+import prepend from './prepend';
+import querySelectorAll from './querySelectorAll';
+import remove from './remove';
+import removeClass from './removeClass';
+import removeEventListener from './removeEventListener';
+import scrollbarSize from './scrollbarSize';
+import scrollLeft from './scrollLeft';
+import scrollParent from './scrollParent';
+import scrollTo from './scrollTo';
+import scrollTop from './scrollTop';
+import siblings from './siblings';
+import text from './text';
+import toggleClass from './toggleClass';
+import transitionEnd from './transitionEnd';
+import triggerEvent from './triggerEvent';
+import width from './width';
+export { activeElement, addClass, addEventListener, animate, attribute, cancelAnimationFrame, childElements, childNodes, clear, closest, contains, filter, getComputedStyle, hasClass, height, insertAfter, isInput, isVisible, listen, matches, nextUntil, offset, offsetParent, ownerDocument, ownerWindow, parents, position, prepend, querySelectorAll, remove, removeClass, removeEventListener, requestAnimationFrame, scrollbarSize, scrollLeft, scrollParent, scrollTo, scrollTop, siblings, style, text, toggleClass, transitionEnd, triggerEvent, width, };
+declare const _default: {
+    addEventListener: typeof addEventListener;
+    removeEventListener: typeof removeEventListener;
+    triggerEvent: typeof triggerEvent;
+    animate: typeof animate;
+    filter: typeof filter;
+    listen: typeof listen;
+    style: typeof style;
+    getComputedStyle: typeof getComputedStyle;
+    attribute: typeof attribute;
+    activeElement: typeof activeElement;
+    ownerDocument: typeof ownerDocument;
+    ownerWindow: typeof ownerWindow;
+    requestAnimationFrame: typeof globalThis.requestAnimationFrame;
+    cancelAnimationFrame: (id: number) => void;
+    matches: typeof matches;
+    height: typeof height;
+    width: typeof width;
+    offset: typeof offset;
+    offsetParent: typeof offsetParent;
+    position: typeof position;
+    contains: typeof contains;
+    scrollbarSize: typeof scrollbarSize;
+    scrollLeft: (node: Element, val?: number) => number | undefined;
+    scrollParent: typeof scrollParent;
+    scrollTo: typeof scrollTo;
+    scrollTop: (node: Element, val?: number) => number | undefined;
+    querySelectorAll: typeof querySelectorAll;
+    closest: typeof closest;
+    addClass: typeof addClass;
+    removeClass: typeof removeClass;
+    hasClass: typeof hasClass;
+    toggleClass: typeof toggleClass;
+    transitionEnd: typeof transitionEnd;
+    childNodes: typeof childNodes;
+    childElements: typeof childElements;
+    nextUntil: typeof nextUntil;
+    parents: typeof parents;
+    siblings: typeof siblings;
+    clear: typeof clear;
+    insertAfter: typeof insertAfter;
+    isInput: typeof isInput;
+    isVisible: typeof isVisible;
+    prepend: typeof prepend;
+    remove: typeof remove;
+    text: typeof text;
+};
+export default _default;

package/types/dom-helpers/insertAfter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Inserts a node after a given reference node.
+ *
+ * @param node the node to insert
+ * @param refNode the reference node
+ */
+export default function insertAfter(node: Node | null, refNode: Node | null): Node | null;

package/types/dom-helpers/isDocument.d.ts

@@ -0,0 +1 @@
+export default function isDocument(element: Element | Document | Window): element is Document;

package/types/dom-helpers/isInput.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if a given element is an input (input, select, textarea or button).
+ *
+ * @param node the element to check
+ */
+export default function isInput(node: Element | null): boolean;

package/types/dom-helpers/isTransform.d.ts

@@ -0,0 +1,2 @@
+export type TransformValue = 'translate' | 'translateY' | 'translateX' | 'translateZ' | 'translate3d' | 'rotate' | 'rotateY' | 'rotateX' | 'rotateZ' | 'rotate3d' | 'scale' | 'scaleY' | 'scaleX' | 'scaleZ' | 'scale3d' | 'matrix' | 'matrix3d' | 'perspective' | 'skew' | 'skewY' | 'skewX';
+export default function isTransform(value: string): value is TransformValue;

package/types/dom-helpers/isVisible.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if a given element is currently visible.
+ *
+ * @param node the element to check
+ */
+export default function isVisible(node: HTMLElement | null): boolean;

package/types/dom-helpers/isWindow.d.ts

@@ -0,0 +1 @@
+export default function isWindow(node: Element | Document | Window): Window | false;

package/types/dom-helpers/listen.d.ts

@@ -0,0 +1,3 @@
+import { EventHandler } from './addEventListener';
+declare function listen<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: EventHandler<K>, options?: boolean | AddEventListenerOptions): () => void;
+export default listen;

package/types/dom-helpers/matches.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a given element matches a selector.
+ *
+ * @param node the element
+ * @param selector the selector
+ */
+export default function matches(node: Element, selector: string): boolean;

package/types/dom-helpers/nextUntil.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Collects all next sibling elements of an element until a given selector is matched.
+ *
+ * @param node the referene node
+ * @param selector the selector to match
+ */
+export default function nextUntil(node: Element | null, selector: string): Element[];

package/types/dom-helpers/offset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns the offset of a given element, including top and left positions, width and height.
+ *
+ * @param node the element
+ */
+export default function offset(node: HTMLElement): {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+};

package/types/dom-helpers/offsetParent.d.ts

@@ -0,0 +1 @@
+export default function offsetParent(node: HTMLElement): HTMLElement;

package/types/dom-helpers/ownerDocument.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the owner document of a given element.
+ *
+ * @param node the element
+ */
+export default function ownerDocument(node?: Element): Document;

package/types/dom-helpers/ownerWindow.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the owner window of a given element.
+ *
+ * @param node the element
+ */
+export default function ownerWindow(node?: Element): Window;

package/types/dom-helpers/parents.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Collects all parent elements of a given element.
+ *
+ * @param node the element
+ */
+export default function parents(node: Element | null): Element[];

package/types/dom-helpers/position.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns the relative position of a given element.
+ *
+ * @param node the element
+ * @param offsetParent the offset parent
+ */
+export default function position(node: HTMLElement, offsetParent?: HTMLElement): {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+} | {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+    bottom: number;
+    right: number;
+    toJSON(): any;
+    toJSON(): any;
+};

package/types/dom-helpers/prepend.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Insert a given element as the first child of a parent element.
+ *
+ * @param node the element to prepend
+ * @param parent the parent element
+ */
+export default function prepend(node: Element | null, parent: Element | null): Element | null;

package/types/dom-helpers/querySelectorAll.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs `querySelectorAll` on a given element.
+ *
+ * @param element the element
+ * @param selector the selector
+ */
+export default function qsa(element: HTMLElement | Document, selector: string): HTMLElement[];

package/types/dom-helpers/reflow.d.ts

@@ -0,0 +1,2 @@
+declare function forceReflow(element?: HTMLElement): number[];
+export default forceReflow;

package/types/dom-helpers/remove.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Removes a given node from the DOM.
+ *
+ * @param node the node to remove
+ */
+export default function remove(node: Node | null): Node | null;

package/types/dom-helpers/removeClass.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes a CSS class from a given element.
+ *
+ * @param element the element
+ * @param className the CSS class name
+ */
+export default function removeClass(element: Element | SVGElement, className: string): void;