@fluixi/utils 1.0.0-alpha.100

package/dist/lib/object/selector.mjs

@@ -0,0 +1,282 @@
+// src/lib/object/selector.ts
+var parseSelector = (selector, options = {}) => {
+  const { type = "auto", throwOnError = false } = options;
+  if (!selector || typeof selector !== "string") {
+    return [];
+  }
+  const segments = [];
+  let current = "";
+  let inBrackets = false;
+  let inQuotes = false;
+  let quoteChar = "";
+  let bracketContent = "";
+  let bracketDepth = 0;
+  const detectType = (str) => {
+    if (str.includes("..")) return "descendant";
+    if (str.includes("[?(")) return "filter";
+    if (str.includes("[:") || str.includes("[0:")) return "slice";
+    if (str.includes("[,") || str.includes("[0,1]")) return "union";
+    if (str.includes("[*]") || str.includes(".*.")) return "wildcard";
+    if (str.includes("[]")) return "array-wildcard";
+    if (str.includes("[") && str.includes("]")) return "bracket";
+    return "dot";
+  };
+  const actualType = type === "auto" ? detectType(selector) : type;
+  const parseBracketContent = (content) => {
+    const trimmed = content.trim();
+    if (trimmed === "*" || trimmed === "") {
+      return {
+        type: "wildcard",
+        value: trimmed === "" ? "[]" : "*",
+        raw: trimmed === "" ? "[]" : content
+      };
+    }
+    if (trimmed === "[]") {
+      return { type: "wildcard", value: "[]", raw: content };
+    }
+    if (/^-?\d+$/.test(trimmed)) {
+      return { type: "index", value: parseInt(trimmed, 10), raw: content };
+    }
+    if (trimmed.includes(":")) {
+      const parts = trimmed.split(":").map((p) => p.trim());
+      const start = parts[0] === "" ? 0 : parseInt(parts[0], 10);
+      const end = parts[1] === "" ? Infinity : parseInt(parts[1], 10);
+      if (isNaN(start) || isNaN(end)) {
+        if (throwOnError) throw new Error(`Invalid slice notation: ${content}`);
+        return { type: "wildcard", value: "*", raw: content };
+      }
+      return { type: "slice", value: [start, end], raw: content };
+    }
+    if (trimmed.includes(",")) {
+      const indices = trimmed.split(",").map((p) => {
+        const num = parseInt(p.trim(), 10);
+        return isNaN(num) ? -1 : num;
+      }).filter((n) => n >= 0);
+      if (indices.length === 0) {
+        if (throwOnError) throw new Error(`Invalid union notation: ${content}`);
+        return { type: "wildcard", value: "*", raw: content };
+      }
+      return { type: "union", value: indices, raw: content };
+    }
+    if (trimmed.startsWith("?(") && trimmed.endsWith(")")) {
+      const expr = trimmed.slice(2, -1);
+      try {
+        const filterFn = createFilterFunction(expr);
+        return { type: "filter", value: filterFn, raw: content };
+      } catch (error) {
+        if (throwOnError) throw error;
+        return { type: "wildcard", value: "*", raw: content };
+      }
+    }
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return { type: "property", value: trimmed.slice(1, -1), raw: content };
+    }
+    return { type: "property", value: trimmed, raw: content };
+  };
+  for (let i = 0; i < selector.length; i++) {
+    const char = selector[i];
+    const nextChar = selector[i + 1];
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+      continue;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+      if (!(char === '"' || char === "'")) {
+        if (inBrackets) {
+          bracketContent += char;
+        } else {
+          current += char;
+        }
+      }
+      continue;
+    }
+    if (inQuotes) {
+      if (inBrackets) {
+        bracketContent += char;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "[" && !inBrackets) {
+      if (current) {
+        segments.push({ type: "property", value: current, raw: current });
+        current = "";
+      }
+      inBrackets = true;
+      bracketContent = "";
+      continue;
+    }
+    if (char === "]" && inBrackets && !inQuotes) {
+      inBrackets = false;
+      const segment = parseBracketContent(bracketContent);
+      segments.push(segment);
+      continue;
+    }
+    let lastDot = segments.length > 0 ? segments[segments.length - 1] : null;
+    if (char === "." && !inBrackets && !inQuotes) {
+      if (nextChar === ".") {
+        const l = selector.split("..")[0];
+        segments.push({ type: "property", value: l, raw: l });
+        segments.push({ type: "descendant", value: "..", raw: ".." });
+        i++;
+      } else if (current) {
+        if (current === "*") {
+          segments.push({ type: "wildcard", value: current, raw: current });
+        } else {
+          segments.push({ type: "property", value: current, raw: current });
+        }
+        current = "";
+      }
+      continue;
+    }
+    if (inBrackets) {
+      bracketContent += char;
+    } else {
+      if (lastDot && lastDot.type !== "descendant") {
+        current += char;
+      } else {
+        const l = selector.split(lastDot?.raw)[1];
+        if (l !== void 0) {
+          current = l;
+        } else {
+          current += char;
+        }
+      }
+    }
+  }
+  if (current) {
+    segments.push({ type: "property", value: current, raw: current });
+  }
+  return segments.map((segment) => {
+    if (segment.type === "property" && typeof segment.value === "string") {
+      if (/^-?\d+$/.test(segment.value)) {
+        const num = parseInt(segment.value, 10);
+        if (!isNaN(num)) {
+          return { ...segment, type: "index", value: num };
+        }
+      }
+    }
+    return segment;
+  });
+};
+var createFilterFunction = (expr) => {
+  const safeExpr = expr.replace(/@\.([a-zA-Z_$][\w$]*)/g, (_, prop) => `item.${prop}`).replace(/@/g, "item");
+  try {
+    return new Function("item", `return ${safeExpr}`);
+  } catch (error) {
+    throw new Error(`Invalid filter expression: ${expr}`);
+  }
+};
+var stringifySelector = (segments) => {
+  const parts = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const prevSegment = i > 0 ? segments[i - 1] : null;
+    switch (segment.type) {
+      case "property":
+        const needsQuotes = /[\.\[\]\s]/.test(String(segment.value));
+        if (needsQuotes) {
+          parts.push(`["${segment.value}"]`);
+        } else {
+          if (prevSegment && prevSegment.type !== "descendant") {
+            parts.push(".");
+          }
+          parts.push(String(segment.value));
+        }
+        break;
+      case "index":
+        parts.push(`[${segment.value}]`);
+        break;
+      case "wildcard":
+        if (segment.value === "[]") {
+          parts.push("[]");
+        } else {
+          parts.push("[*]");
+        }
+        break;
+      case "slice":
+        const [start, end] = segment.value;
+        parts.push(`[${start}:${end === Infinity ? "" : end}]`);
+        break;
+      case "union":
+        const indices = segment.value;
+        parts.push(`[${indices.join(",")}]`);
+        break;
+      case "filter":
+        parts.push(`[?(${segment.raw?.slice(2, -1) || ""})]`);
+        break;
+      case "descendant":
+        parts.push("..");
+        break;
+    }
+  }
+  return parts.join("").replace(/\.\[/g, "[");
+};
+var validateSelector = (selector, options = {}) => {
+  if (Array.isArray(selector)) {
+    return selector.map(
+      (sel) => validateSelector(sel, options)
+    );
+  }
+  if (!/^[a-zA-Z]/.test(selector)) {
+    return {
+      valid: false,
+      error: `Selector starts with '.'`,
+      type: detectSelectorType(selector)
+    };
+  }
+  if (!/[a-zA-Z]$/.test(selector)) {
+    return {
+      valid: false,
+      error: `Selector end with '.'`,
+      type: detectSelectorType(selector)
+    };
+  }
+  try {
+    const segments = parseSelector(selector, { throwOnError: true });
+    const type = detectSelectorType(selector);
+    if (options.allowedTypes) {
+      if (!options.allowedTypes.includes(type)) {
+        return {
+          valid: false,
+          error: `Selector type ${type} not allowed. Allowed: ${options.allowedTypes.join(
+            ", "
+          )}`,
+          type
+        };
+      }
+    }
+    return { valid: true, type: detectSelectorType(selector) };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+};
+var detectSelectorType = (selector) => {
+  if (selector.includes("..")) return "descendant";
+  if (selector.includes("[?(")) return "filter";
+  if (selector.includes("[:") || selector.includes("[0:")) return "slice";
+  if (/\[[^\]]*,[^\]]*\]/.test(selector)) return "union";
+  if (selector.includes("[*]") || selector.includes(".*.")) return "wildcard";
+  if (selector.includes("[]")) return "array-wildcard";
+  if (selector.includes("[") && selector.includes("]")) return "bracket";
+  return "dot";
+};
+var createSelector = (template, replacements) => {
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    if (key in replacements) {
+      return String(replacements[key]);
+    }
+    return `{${key}}`;
+  });
+};
+export {
+  createFilterFunction,
+  createSelector,
+  detectSelectorType,
+  parseSelector,
+  stringifySelector,
+  validateSelector
+};

package/dist/lib/object/sort.cjs

@@ -0,0 +1,209 @@
+"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);
+
+// src/lib/object/sort.ts
+var sort_exports = {};
+__export(sort_exports, {
+  move: () => move,
+  reorder: () => reorder,
+  sort: () => sort,
+  sortBy: () => sortBy,
+  sortKeys: () => sortKeys,
+  swap: () => swap
+});
+module.exports = __toCommonJS(sort_exports);
+
+// src/lib/object/utils.ts
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/lib/object/sort.ts
+function getAtPath(obj, path) {
+  if (obj == null) return void 0;
+  let cur = obj;
+  for (const segment of path.split(".")) {
+    if (cur == null) return void 0;
+    cur = cur[segment];
+  }
+  return cur;
+}
+function compareValues(a, b, locale, localeOptions) {
+  const aN = a == null;
+  const bN = b == null;
+  if (aN && bN) return 0;
+  if (aN) return 1;
+  if (bN) return -1;
+  const aNaN = typeof a === "number" && Number.isNaN(a);
+  const bNaN = typeof b === "number" && Number.isNaN(b);
+  if (aNaN && bNaN) return 0;
+  if (aNaN) return 1;
+  if (bNaN) return -1;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() - b.getTime();
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b ? 0 : a ? 1 : -1;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.localeCompare(b, locale, localeOptions);
+  }
+  return String(a).localeCompare(String(b), locale, localeOptions);
+}
+function dirFor(order, i) {
+  const o = Array.isArray(order) ? order[i] ?? "asc" : order ?? "asc";
+  return o === "desc" ? -1 : 1;
+}
+function sortPrimitiveArray(arr, options) {
+  const { order, locale, localeOptions, nullsLast = true } = options;
+  const dir = dirFor(order, 0);
+  return arr.slice().sort((a, b) => {
+    const aN = a == null;
+    const bN = b == null;
+    if (aN && bN) return 0;
+    if (aN) return nullsLast ? 1 : -1;
+    if (bN) return nullsLast ? -1 : 1;
+    return compareValues(a, b, locale, localeOptions) * dir;
+  });
+}
+function sortObjectArray(arr, keys, options) {
+  const { order, locale, localeOptions, nullsLast = true, comparator } = options;
+  if (comparator) {
+    return arr.slice().sort(comparator);
+  }
+  return arr.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const aVal = getAtPath(a, keys[i]);
+      const bVal = getAtPath(b, keys[i]);
+      const aN = aVal == null;
+      const bN = bVal == null;
+      if (aN && bN) continue;
+      if (aN) return nullsLast ? 1 : -1;
+      if (bN) return nullsLast ? -1 : 1;
+      const cmp = compareValues(aVal, bVal, locale, localeOptions);
+      if (cmp !== 0) return cmp * dirFor(order, i);
+    }
+    return 0;
+  });
+}
+function sortRecord(record, options) {
+  const { order, priorityKeys = [], locale, localeOptions, deep } = options;
+  const dir = dirFor(order, 0);
+  const prioritySet = new Set(priorityKeys);
+  const rest = Object.keys(record).filter((k) => !prioritySet.has(k));
+  rest.sort(
+    (a, b) => a.localeCompare(b, locale, localeOptions) * dir
+  );
+  const ordered = [...priorityKeys.filter((k) => k in record), ...rest];
+  const result = {};
+  for (const key of ordered) {
+    result[key] = deep ? sortDeep(record[key], options) : record[key];
+  }
+  return result;
+}
+function sortDeep(value, options) {
+  if (Array.isArray(value)) {
+    const deepSorted = value.map((item) => sortDeep(item, options));
+    return sortArrayValue(deepSorted, options);
+  }
+  if (isPlainObject(value)) {
+    return sortRecord(value, options);
+  }
+  return value;
+}
+function applyIndices(arr, indices) {
+  const len = arr.length;
+  const used = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const idx of indices) {
+    if (idx >= 0 && idx < len && !used.has(idx)) {
+      result.push(arr[idx]);
+      used.add(idx);
+    }
+  }
+  for (let i = 0; i < len; i++) {
+    if (!used.has(i)) result.push(arr[i]);
+  }
+  return result;
+}
+function sortArrayValue(arr, options) {
+  const { by, comparator, indices, order } = options;
+  if (indices) {
+    const permuted = applyIndices(arr, indices);
+    return dirFor(order, 0) === -1 ? permuted.reverse() : permuted;
+  }
+  if (comparator) {
+    return arr.slice().sort(comparator);
+  }
+  if (by) {
+    const keys = Array.isArray(by) ? by : [by];
+    return sortObjectArray(arr, keys, options);
+  }
+  const firstReal = arr.find((x) => x != null);
+  if (firstReal != null && isPlainObject(firstReal)) {
+    return dirFor(order, 0) === -1 ? arr.slice().reverse() : arr.slice();
+  }
+  return sortPrimitiveArray(arr, options);
+}
+function sort(input, options = {}) {
+  const { deep } = options;
+  if (Array.isArray(input)) {
+    const items = deep ? input.map((item) => sortDeep(item, options)) : input;
+    return sortArrayValue(items, options);
+  }
+  if (isPlainObject(input)) {
+    return sortRecord(input, options);
+  }
+  return input;
+}
+function sortBy(arr, by, order = "asc", options = {}) {
+  return sort(arr, { ...options, by, order });
+}
+function sortKeys(record, options = {}) {
+  return sort(record, options);
+}
+function move(arr, from, to) {
+  const len = arr.length;
+  if (len === 0) return arr.slice();
+  const f = Math.max(0, Math.min(len - 1, from));
+  const t = Math.max(0, Math.min(len - 1, to));
+  if (f === t) return arr.slice();
+  const result = arr.slice();
+  const [item] = result.splice(f, 1);
+  result.splice(t, 0, item);
+  return result;
+}
+function swap(arr, i, j) {
+  const len = arr.length;
+  if (i < 0 || i >= len) throw new RangeError(`swap: index ${i} out of range`);
+  if (j < 0 || j >= len) throw new RangeError(`swap: index ${j} out of range`);
+  if (i === j) return arr.slice();
+  const result = arr.slice();
+  result[i] = arr[j];
+  result[j] = arr[i];
+  return result;
+}
+function reorder(arr, indices, order = "asc") {
+  return sort(arr, { indices, order });
+}

package/dist/lib/object/sort.d.ts

@@ -0,0 +1,149 @@
+import type { AnyObject, SelectorFor } from './types.js';
+export type SortOrder = 'asc' | 'desc';
+/**
+ * Options for `sort()`.
+ *
+ * @template T - Element type when sorting an array, or the record type.
+ *
+ * Array sorting
+ *   sort(users, { by: 'name' })
+ *   sort(users, { by: ['lastName', 'firstName'], order: ['asc', 'asc'] })
+ *   sort(scores, { order: 'desc' })
+ *   sort(items, { comparator: (a, b) => a.priority - b.priority })
+ *
+ * Record sorting (orders keys)
+ *   sort(config, { priorityKeys: ['id', 'name'] })
+ *
+ * Deep / recursive
+ *   sort(tree, { deep: true })
+ */
+export interface SortOptions<T = any> {
+    /**
+     * Key path(s) used to compare object array elements.
+     * Supports dot-notation for nested access: `'address.city'`.
+     * When multiple keys are given, they act as tie-breakers left-to-right.
+     * Only meaningful for object arrays; ignored for primitive arrays and records.
+     */
+    by?: T extends AnyObject ? SelectorFor<T> | SelectorFor<T>[] : string | string[];
+    /**
+     * Sort direction.  When `by` is an array you may supply a parallel array
+     * of directions: one per key.  A single value applies to all keys.
+     * Default: `'asc'`.
+     */
+    order?: SortOrder | SortOrder[];
+    /**
+     * Recursively sort nested arrays and plain-object values.
+     * Default: `false`.
+     */
+    deep?: boolean;
+    /**
+     * For record-key sorting: these keys are placed first, in the given order,
+     * before the remaining keys are sorted alphabetically.
+     */
+    priorityKeys?: string[];
+    /**
+     * Put `null` / `undefined` array elements at the end regardless of direction.
+     * Default: `true`.
+     */
+    nullsLast?: boolean;
+    /** BCP 47 locale tag used for string comparison, e.g. `'en-US'`. */
+    locale?: string;
+    /** Additional options forwarded to `Intl.Collator` when comparing strings. */
+    localeOptions?: Intl.CollatorOptions;
+    /**
+     * Explicit index permutation for arrays.
+     * `indices[i]` is the source index in the input array that should appear at
+     * position `i` in the output.
+     *
+     * - Input elements not referenced by any index are appended at the end in
+     *   their original relative order.
+     * - Out-of-range indices are silently skipped.
+     * - When combined with `order: 'desc'`, the permuted result is reversed.
+     *
+     * @example
+     * sort(['a','b','c'], { indices: [2, 0, 1] }) // ['c', 'a', 'b']
+     * sort(['a','b','c'], { indices: [1, 0] })     // ['b', 'a', 'c']  ('c' appended)
+     * sort(users, { indices: [3, 1, 0, 2] })       // explicit UI reorder
+     */
+    indices?: number[];
+    /**
+     * Fully custom comparator. When supplied it overrides `by`, `order`, and
+     * locale settings; only `deep` and `priorityKeys` still apply.
+     */
+    comparator?: (a: T, b: T) => number;
+}
+/**
+ * Sort an array of any element type.
+ *
+ * @example
+ * sort([3, 1, 2])                            // [1, 2, 3]
+ * sort(['banana', 'apple', 'cherry'])        // ['apple', 'banana', 'cherry']
+ * sort(users, { by: 'name' })
+ * sort(users, { by: ['role', 'name'], order: ['asc', 'desc'] })
+ * sort(items, { order: 'desc', deep: true })
+ */
+export declare function sort<T>(input: T[], options?: SortOptions<T>): T[];
+/**
+ * Sort the keys of a plain-object record, returning a new object with the
+ * same entries but with keys in alphabetical order.
+ *
+ * @example
+ * sort({ z: 1, a: 2, m: 3 })                       // { a: 2, m: 3, z: 1 }
+ * sort(config, { priorityKeys: ['id', 'name'] })
+ * sort(tree,   { deep: true })
+ */
+export declare function sort<T extends Record<string, any>>(input: T, options?: SortOptions): T;
+/**
+ * Sort an array of objects by one or more key paths, returning a new array.
+ * Shorthand for `sort(arr, { by: key, order })`.
+ *
+ * @example
+ * sortBy(users, 'name')
+ * sortBy(users, ['lastName', 'firstName'], 'asc')
+ * sortBy(products, 'price', 'desc')
+ */
+export declare function sortBy<T extends object>(arr: T[], by: T extends AnyObject ? SelectorFor<T> | SelectorFor<T>[] : string | string[], order?: SortOrder | SortOrder[], options?: Omit<SortOptions<T>, 'by' | 'order'>): T[];
+/**
+ * Sort the keys of a record object, returning a new object.
+ * Shorthand for `sort(record, { order, priorityKeys, deep })`.
+ *
+ * @example
+ * sortKeys({ z: 1, a: 2 })                        // { a: 2, z: 1 }
+ * sortKeys(obj, { priorityKeys: ['id', 'type'] })
+ * sortKeys(tree, { deep: true })
+ */
+export declare function sortKeys<T extends Record<string, any>>(record: T, options?: Pick<SortOptions, 'order' | 'priorityKeys' | 'deep' | 'locale' | 'localeOptions'>): T;
+/**
+ * Move an element from one index to another, shifting the elements in between.
+ * Returns a new array; the original is not mutated.
+ *
+ * - Clamps `from` and `to` to valid array bounds.
+ * - When `from === to` the original array is returned as-is (same reference).
+ *
+ * @example
+ * move(['a','b','c','d'], 0, 2)  // ['b','c','a','d']  (first → third)
+ * move(['a','b','c','d'], 3, 1)  // ['a','d','b','c']  (last  → second)
+ * move(users, fromIndex, toIndex)
+ */
+export declare function move<T>(arr: T[], from: number, to: number): T[];
+/**
+ * Swap two elements by index, returning a new array.
+ * The original array is not mutated.
+ * Out-of-range indices throw a `RangeError`.
+ *
+ * @example
+ * swap(['a','b','c'], 0, 2)  // ['c','b','a']
+ * swap(users, 1, 3)
+ */
+export declare function swap<T>(arr: T[], i: number, j: number): T[];
+/**
+ * Reorder an array by providing the full desired sequence of source indices.
+ * Shorthand for `sort(arr, { indices })`.
+ *
+ * @example
+ * reorder(['a','b','c'], [2, 0, 1])          // ['c','a','b']
+ * reorder(tabs, newIndexOrder)               // apply UI drag-and-drop result
+ * reorder(rows, [3,1,0,2], 'desc')           // permute then reverse
+ */
+export declare function reorder<T>(arr: T[], indices: number[], order?: SortOrder): T[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/lib/object/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../src/lib/object/sort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIzD,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG;IAClC;;;;;OAKG;IACH,EAAE,CAAC,EAAE,CAAC,SAAS,SAAS,GACpB,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,GACjC,MAAM,GAAG,MAAM,EAAE,CAAC;IAEtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;IAEhC;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC;IAErC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;CACrC;AA2OD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;AAEnE;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChD,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,WAAW,GACpB,CAAC,CAAC;AAwBL;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EACrC,GAAG,EAAE,CAAC,EAAE,EACR,EAAE,EAAE,CAAC,SAAS,SAAS,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,EAC/E,KAAK,GAAE,SAAS,GAAG,SAAS,EAAU,EACtC,OAAO,GAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAM,GACjD,CAAC,EAAE,CAEL;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACpD,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,eAAe,CAAM,GAC9F,CAAC,CAEH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,CAAC,EAAE,CAY/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,CAU3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,CAAC,EAAE,EACR,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,GAAE,SAAiB,GACvB,CAAC,EAAE,CAEL"}