@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/object/selector.mjs

@@ -1 +1,282 @@
-var g=(t,n={})=>{let{type:l="auto",throwOnError:i=!1}=n;if(!t||typeof t!="string")return[];let s=[],a="",o=!1,d=!1,f="",y="",b=0,T=l==="auto"?(r=>r.includes("..")?"descendant":r.includes("[?(")?"filter":r.includes("[:")||r.includes("[0:")?"slice":r.includes("[,")||r.includes("[0,1]")?"union":r.includes("[*]")||r.includes(".*.")?"wildcard":r.includes("[]")?"array-wildcard":r.includes("[")&&r.includes("]")?"bracket":"dot")(t):l,h=r=>{let e=r.trim();if(e==="*"||e==="")return{type:"wildcard",value:e===""?"[]":"*",raw:e===""?"[]":r};if(e==="[]")return{type:"wildcard",value:"[]",raw:r};if(/^-?\d+$/.test(e))return{type:"index",value:parseInt(e,10),raw:r};if(e.includes(":")){let c=e.split(":").map(v=>v.trim()),u=c[0]===""?0:parseInt(c[0],10),p=c[1]===""?1/0:parseInt(c[1],10);if(isNaN(u)||isNaN(p)){if(i)throw new Error(`Invalid slice notation: ${r}`);return{type:"wildcard",value:"*",raw:r}}return{type:"slice",value:[u,p],raw:r}}if(e.includes(",")){let c=e.split(",").map(u=>{let p=parseInt(u.trim(),10);return isNaN(p)?-1:p}).filter(u=>u>=0);if(c.length===0){if(i)throw new Error(`Invalid union notation: ${r}`);return{type:"wildcard",value:"*",raw:r}}return{type:"union",value:c,raw:r}}if(e.startsWith("?(")&&e.endsWith(")")){let c=e.slice(2,-1);try{return{type:"filter",value:S(c),raw:r}}catch(u){if(i)throw u;return{type:"wildcard",value:"*",raw:r}}}return e.startsWith('"')&&e.endsWith('"')||e.startsWith("'")&&e.endsWith("'")?{type:"property",value:e.slice(1,-1),raw:r}:{type:"property",value:e,raw:r}};for(let r=0;r<t.length;r++){let e=t[r],c=t[r+1];if((e==='"'||e==="'")&&!d){d=!0,f=e;continue}else if(e===f&&d){d=!1,f="",e==='"'||e==="'"||(o?y+=e:a+=e);continue}if(d){o?y+=e:a+=e;continue}if(e==="["&&!o){a&&(s.push({type:"property",value:a,raw:a}),a=""),o=!0,y="";continue}if(e==="]"&&o&&!d){o=!1;let p=h(y);s.push(p);continue}let u=s.length>0?s[s.length-1]:null;if(e==="."&&!o&&!d){if(c==="."){let p=t.split("..")[0];s.push({type:"property",value:p,raw:p}),s.push({type:"descendant",value:"..",raw:".."}),r++}else a&&(a==="*"?s.push({type:"wildcard",value:a,raw:a}):s.push({type:"property",value:a,raw:a}),a="");continue}if(o)y+=e;else if(u&&u.type!=="descendant")a+=e;else{let p=t.split(u?.raw)[1];p!==void 0?a=p:a+=e}}return a&&s.push({type:"property",value:a,raw:a}),s.map(r=>{if(r.type==="property"&&typeof r.value=="string"&&/^-?\d+$/.test(r.value)){let e=parseInt(r.value,10);if(!isNaN(e))return{...r,type:"index",value:e}}return r})},S=t=>{let n=t.replace(/@\.([a-zA-Z_$][\w$]*)/g,(l,i)=>`item.${i}`).replace(/@/g,"item");try{return new Function("item",`return ${n}`)}catch{throw new Error(`Invalid filter expression: ${t}`)}},x=t=>{let n=[];for(let l=0;l<t.length;l++){let i=t[l],s=l>0?t[l-1]:null;switch(i.type){case"property":/[\.\[\]\s]/.test(String(i.value))?n.push(`["${i.value}"]`):(s&&s.type!=="descendant"&&n.push("."),n.push(String(i.value)));break;case"index":n.push(`[${i.value}]`);break;case"wildcard":i.value==="[]"?n.push("[]"):n.push("[*]");break;case"slice":let[o,d]=i.value;n.push(`[${o}:${d===1/0?"":d}]`);break;case"union":let f=i.value;n.push(`[${f.join(",")}]`);break;case"filter":n.push(`[?(${i.raw?.slice(2,-1)||""})]`);break;case"descendant":n.push("..");break}}return n.join("").replace(/\.\[/g,"[")},m=(t,n={})=>{if(Array.isArray(t))return t.map(l=>m(l,n));if(!/^[a-zA-Z]/.test(t))return{valid:!1,error:"Selector starts with '.'",type:w(t)};if(!/[a-zA-Z]$/.test(t))return{valid:!1,error:"Selector end with '.'",type:w(t)};try{let l=g(t,{throwOnError:!0}),i=w(t);return n.allowedTypes&&!n.allowedTypes.includes(i)?{valid:!1,error:`Selector type ${i} not allowed. Allowed: ${n.allowedTypes.join(", ")}`,type:i}:{valid:!0,type:w(t)}}catch(l){return{valid:!1,error:l.message}}},w=t=>t.includes("..")?"descendant":t.includes("[?(")?"filter":t.includes("[:")||t.includes("[0:")?"slice":/\[[^\]]*,[^\]]*\]/.test(t)?"union":t.includes("[*]")||t.includes(".*.")?"wildcard":t.includes("[]")?"array-wildcard":t.includes("[")&&t.includes("]")?"bracket":"dot",k=(t,n)=>t.replace(/\{(\w+)\}/g,(l,i)=>i in n?String(n[i]):`{${i}}`);export{S as createFilterFunction,k as createSelector,w as detectSelectorType,g as parseSelector,x as stringifySelector,m as validateSelector};
+// 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

@@ -1 +1,209 @@
-"use strict";var g=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var N=(e,n)=>{for(var t in n)g(e,t,{get:n[t],enumerable:!0})},$=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of w(n))!k.call(e,o)&&o!==t&&g(e,o,{get:()=>n[o],enumerable:!(r=h(n,o))||r.enumerable});return e};var C=e=>$(g({},"__esModule",{value:!0}),e);var L={};N(L,{move:()=>K,reorder:()=>J,sort:()=>T,sortBy:()=>M,sortKeys:()=>I,swap:()=>V});module.exports=C(L);function b(e){if(typeof e!="object"||e===null)return!1;let n=Object.getPrototypeOf(e);return n===Object.prototype||n===null}function A(e,n){if(e==null)return;let t=e;for(let r of n.split(".")){if(t==null)return;t=t[r]}return t}function R(e,n,t,r){let o=e==null,s=n==null;if(o&&s)return 0;if(o)return 1;if(s)return-1;let u=typeof e=="number"&&Number.isNaN(e),i=typeof n=="number"&&Number.isNaN(n);return u&&i?0:u?1:i?-1:e instanceof Date&&n instanceof Date?e.getTime()-n.getTime():typeof e=="boolean"&&typeof n=="boolean"?e===n?0:e?1:-1:typeof e=="number"&&typeof n=="number"?e-n:typeof e=="string"&&typeof n=="string"?e.localeCompare(n,t,r):String(e).localeCompare(String(n),t,r)}function y(e,n){return(Array.isArray(e)?e[n]??"asc":e??"asc")==="desc"?-1:1}function F(e,n){let{order:t,locale:r,localeOptions:o,nullsLast:s=!0}=n,u=y(t,0);return e.slice().sort((i,c)=>{let l=i==null,a=c==null;return l&&a?0:l?s?1:-1:a?s?-1:1:R(i,c,r,o)*u})}function E(e,n,t){let{order:r,locale:o,localeOptions:s,nullsLast:u=!0,comparator:i}=t;return i?e.slice().sort(i):e.slice().sort((c,l)=>{for(let a=0;a<n.length;a++){let d=A(c,n[a]),f=A(l,n[a]),p=d==null,O=f==null;if(p&&O)continue;if(p)return u?1:-1;if(O)return u?-1:1;let S=R(d,f,o,s);if(S!==0)return S*y(r,a)}return 0})}function j(e,n){let{order:t,priorityKeys:r=[],locale:o,localeOptions:s,deep:u}=n,i=y(t,0),c=new Set(r),l=Object.keys(e).filter(f=>!c.has(f));l.sort((f,p)=>f.localeCompare(p,o,s)*i);let a=[...r.filter(f=>f in e),...l],d={};for(let f of a)d[f]=u?m(e[f],n):e[f];return d}function m(e,n){if(Array.isArray(e)){let t=e.map(r=>m(r,n));return x(t,n)}return b(e)?j(e,n):e}function P(e,n){let t=e.length,r=new Set,o=[];for(let s of n)s>=0&&s<t&&!r.has(s)&&(o.push(e[s]),r.add(s));for(let s=0;s<t;s++)r.has(s)||o.push(e[s]);return o}function x(e,n){let{by:t,comparator:r,indices:o,order:s}=n;if(o){let i=P(e,o);return y(s,0)===-1?i.reverse():i}if(r)return e.slice().sort(r);if(t){let i=Array.isArray(t)?t:[t];return E(e,i,n)}let u=e.find(i=>i!=null);return u!=null&&b(u)?y(s,0)===-1?e.slice().reverse():e.slice():F(e,n)}function T(e,n={}){let{deep:t}=n;if(Array.isArray(e)){let r=t?e.map(o=>m(o,n)):e;return x(r,n)}return b(e)?j(e,n):e}function M(e,n,t="asc",r={}){return T(e,{...r,by:n,order:t})}function I(e,n={}){return T(e,n)}function K(e,n,t){let r=e.length;if(r===0)return e.slice();let o=Math.max(0,Math.min(r-1,n)),s=Math.max(0,Math.min(r-1,t));if(o===s)return e.slice();let u=e.slice(),[i]=u.splice(o,1);return u.splice(s,0,i),u}function V(e,n,t){let r=e.length;if(n<0||n>=r)throw new RangeError(`swap: index ${n} out of range`);if(t<0||t>=r)throw new RangeError(`swap: index ${t} out of range`);if(n===t)return e.slice();let o=e.slice();return o[n]=e[t],o[t]=e[n],o}function J(e,n,t="asc"){return T(e,{indices:n,order:t})}
+"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 });
+}