qstd 0.3.84 → 0.3.86

package/dist/client/index.cjs

@@ -1089,6 +1089,126 @@ function remove(path, body, opts) {
   );
 }
 
+// src/shared/lexorank/index.ts
+var lexorank_exports = {};
+__export(lexorank_exports, {
+  checkBalance: () => checkBalance,
+  createOrderStr: () => createOrderStr,
+  createRebalancedOrderList: () => createRebalancedOrderList,
+  rebalance: () => rebalance,
+  sortByOrder: () => sortByOrder
+});
+
+// src/shared/lexorank/literals.ts
+var LOWER_BOUND = 96;
+var UPPER_BOUND = 123;
+var CHAR_A = 97;
+var CHAR_Z = 122;
+var ALPHABET_SIZE = 26;
+var DISTRIBUTION_TABLE = [
+  0,
+  4096,
+  65792,
+  528416,
+  1081872,
+  2167048,
+  2376776,
+  4756004,
+  4794660,
+  5411476,
+  9775442,
+  11097386,
+  11184810,
+  22369621
+];
+
+// src/shared/lexorank/fns.ts
+var stripTrailingAs = (str) => {
+  let last = str.length - 1;
+  while (str.charAt(last) === "a") --last;
+  return str.slice(0, last + 1);
+};
+var partialAlphabet = (num2) => {
+  let bits = num2 < 13 ? DISTRIBUTION_TABLE[num2] ?? 0 : 33554431 - (DISTRIBUTION_TABLE[25 - num2] ?? 0);
+  const chars = [];
+  for (let i = 1; i < ALPHABET_SIZE; i++, bits >>= 1) {
+    if (bits & 1) chars.push(String.fromCharCode(CHAR_A + i));
+  }
+  return chars;
+};
+
+// src/shared/lexorank/domain.ts
+var createOrderStr = (prev = "", next = "") => {
+  let p;
+  let n;
+  let pos;
+  let str;
+  for (pos = 0; p === n; pos++) {
+    p = pos < prev.length ? prev.charCodeAt(pos) : LOWER_BOUND;
+    n = pos < next.length ? next.charCodeAt(pos) : UPPER_BOUND;
+  }
+  str = prev.slice(0, pos - 1);
+  if (p === LOWER_BOUND) {
+    while (n === CHAR_A) {
+      n = pos < next.length ? next.charCodeAt(pos++) : UPPER_BOUND;
+      str += "a";
+    }
+    if (n === CHAR_A + 1) {
+      str += "a";
+      n = UPPER_BOUND;
+    }
+  } else if (p !== void 0 && n !== void 0 && p + 1 === n) {
+    str += String.fromCharCode(p);
+    n = UPPER_BOUND;
+    while ((p = pos < prev.length ? prev.charCodeAt(pos++) : LOWER_BOUND) === CHAR_Z) {
+      str += "z";
+    }
+  }
+  return str + String.fromCharCode(
+    Math.ceil(((p ?? LOWER_BOUND) + (n ?? UPPER_BOUND)) / 2)
+  );
+};
+var createRebalancedOrderList = (num2) => {
+  const chars = Math.floor(Math.log(num2) / Math.log(ALPHABET_SIZE)) + 1;
+  const prev = Math.pow(ALPHABET_SIZE, chars - 1);
+  const ratio = chars > 1 ? (num2 + 1 - prev) / prev : num2;
+  const part = Math.floor(ratio);
+  const alpha = [partialAlphabet(part), partialAlphabet(part + 1)];
+  const leapStep = ratio % 1;
+  let leapTotal = 0.5;
+  let first = true;
+  const strings = [];
+  const generate = (full, str) => {
+    if (full) {
+      for (let i = 0; i < ALPHABET_SIZE; i++) {
+        generate(full - 1, str + String.fromCharCode(CHAR_A + i));
+      }
+    } else {
+      if (!first) strings.push(stripTrailingAs(str));
+      else first = false;
+      const leap = Math.floor(leapTotal += leapStep);
+      leapTotal %= 1;
+      for (let i = 0; i < part + leap; i++) {
+        strings.push(str + (alpha[leap]?.[i] ?? ""));
+      }
+    }
+  };
+  generate(chars - 1, "");
+  return strings;
+};
+var checkBalance = (xs) => {
+  let largestOrderStr = 0;
+  xs.forEach(
+    (x) => largestOrderStr = Math.max(largestOrderStr, x.order.length)
+  );
+  return largestOrderStr > xs.length / 2;
+};
+var rebalance = (xs) => {
+  const rebalancedOrderList = createRebalancedOrderList(xs.length);
+  return xs.map((x, i) => ({ ...x, order: rebalancedOrderList[i] ?? x.order }));
+};
+var sortByOrder = (xs) => xs.toSorted((a, b) => (a.order ?? "").localeCompare(b.order ?? ""));
+
 // src/client/haptics.ts
 var haptics_exports = {};
 __export(haptics_exports, {
@@ -1196,6 +1316,7 @@ exports.Dom = dom_exports;
 exports.Flow = flow_exports;
 exports.Haptics = haptics_exports;
 exports.Int = int_exports;
+exports.LexoRank = lexorank_exports;
 exports.List = list_exports;
 exports.Log = log_exports;
 exports.Money = money_exports;

package/dist/client/index.d.ts

@@ -8,6 +8,7 @@ export * as Flow from "../shared/flow";
 export * as Random from "../shared/random";
 export * as Log from "../shared/log";
 export * as Api from "../shared/api";
+export * as LexoRank from "../shared/lexorank";
 export * as Haptics from "./haptics";
 export { Theme } from "./theme";
 export * as Dom from "./dom";

package/dist/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AAGrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAC;AAG/C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC"}

package/dist/client/index.js

@@ -1082,6 +1082,126 @@ function remove(path, body, opts) {
   );
 }
 
+// src/shared/lexorank/index.ts
+var lexorank_exports = {};
+__export(lexorank_exports, {
+  checkBalance: () => checkBalance,
+  createOrderStr: () => createOrderStr,
+  createRebalancedOrderList: () => createRebalancedOrderList,
+  rebalance: () => rebalance,
+  sortByOrder: () => sortByOrder
+});
+
+// src/shared/lexorank/literals.ts
+var LOWER_BOUND = 96;
+var UPPER_BOUND = 123;
+var CHAR_A = 97;
+var CHAR_Z = 122;
+var ALPHABET_SIZE = 26;
+var DISTRIBUTION_TABLE = [
+  0,
+  4096,
+  65792,
+  528416,
+  1081872,
+  2167048,
+  2376776,
+  4756004,
+  4794660,
+  5411476,
+  9775442,
+  11097386,
+  11184810,
+  22369621
+];
+
+// src/shared/lexorank/fns.ts
+var stripTrailingAs = (str) => {
+  let last = str.length - 1;
+  while (str.charAt(last) === "a") --last;
+  return str.slice(0, last + 1);
+};
+var partialAlphabet = (num2) => {
+  let bits = num2 < 13 ? DISTRIBUTION_TABLE[num2] ?? 0 : 33554431 - (DISTRIBUTION_TABLE[25 - num2] ?? 0);
+  const chars = [];
+  for (let i = 1; i < ALPHABET_SIZE; i++, bits >>= 1) {
+    if (bits & 1) chars.push(String.fromCharCode(CHAR_A + i));
+  }
+  return chars;
+};
+
+// src/shared/lexorank/domain.ts
+var createOrderStr = (prev = "", next = "") => {
+  let p;
+  let n;
+  let pos;
+  let str;
+  for (pos = 0; p === n; pos++) {
+    p = pos < prev.length ? prev.charCodeAt(pos) : LOWER_BOUND;
+    n = pos < next.length ? next.charCodeAt(pos) : UPPER_BOUND;
+  }
+  str = prev.slice(0, pos - 1);
+  if (p === LOWER_BOUND) {
+    while (n === CHAR_A) {
+      n = pos < next.length ? next.charCodeAt(pos++) : UPPER_BOUND;
+      str += "a";
+    }
+    if (n === CHAR_A + 1) {
+      str += "a";
+      n = UPPER_BOUND;
+    }
+  } else if (p !== void 0 && n !== void 0 && p + 1 === n) {
+    str += String.fromCharCode(p);
+    n = UPPER_BOUND;
+    while ((p = pos < prev.length ? prev.charCodeAt(pos++) : LOWER_BOUND) === CHAR_Z) {
+      str += "z";
+    }
+  }
+  return str + String.fromCharCode(
+    Math.ceil(((p ?? LOWER_BOUND) + (n ?? UPPER_BOUND)) / 2)
+  );
+};
+var createRebalancedOrderList = (num2) => {
+  const chars = Math.floor(Math.log(num2) / Math.log(ALPHABET_SIZE)) + 1;
+  const prev = Math.pow(ALPHABET_SIZE, chars - 1);
+  const ratio = chars > 1 ? (num2 + 1 - prev) / prev : num2;
+  const part = Math.floor(ratio);
+  const alpha = [partialAlphabet(part), partialAlphabet(part + 1)];
+  const leapStep = ratio % 1;
+  let leapTotal = 0.5;
+  let first = true;
+  const strings = [];
+  const generate = (full, str) => {
+    if (full) {
+      for (let i = 0; i < ALPHABET_SIZE; i++) {
+        generate(full - 1, str + String.fromCharCode(CHAR_A + i));
+      }
+    } else {
+      if (!first) strings.push(stripTrailingAs(str));
+      else first = false;
+      const leap = Math.floor(leapTotal += leapStep);
+      leapTotal %= 1;
+      for (let i = 0; i < part + leap; i++) {
+        strings.push(str + (alpha[leap]?.[i] ?? ""));
+      }
+    }
+  };
+  generate(chars - 1, "");
+  return strings;
+};
+var checkBalance = (xs) => {
+  let largestOrderStr = 0;
+  xs.forEach(
+    (x) => largestOrderStr = Math.max(largestOrderStr, x.order.length)
+  );
+  return largestOrderStr > xs.length / 2;
+};
+var rebalance = (xs) => {
+  const rebalancedOrderList = createRebalancedOrderList(xs.length);
+  return xs.map((x, i) => ({ ...x, order: rebalancedOrderList[i] ?? x.order }));
+};
+var sortByOrder = (xs) => xs.toSorted((a, b) => (a.order ?? "").localeCompare(b.order ?? ""));
+
 // src/client/haptics.ts
 var haptics_exports = {};
 __export(haptics_exports, {
@@ -1183,4 +1303,4 @@ var copy = async (text) => {
   }
 };
 
-export { api_exports as Api, dict_exports as Dict, dom_exports as Dom, flow_exports as Flow, haptics_exports as Haptics, int_exports as Int, list_exports as List, log_exports as Log, money_exports as Money, random_exports as Random, str_exports as Str, Theme, time_exports as Time };
+export { api_exports as Api, dict_exports as Dict, dom_exports as Dom, flow_exports as Flow, haptics_exports as Haptics, int_exports as Int, lexorank_exports as LexoRank, list_exports as List, log_exports as Log, money_exports as Money, random_exports as Random, str_exports as Str, Theme, time_exports as Time };

package/dist/server/index.cjs

@@ -1101,6 +1101,126 @@ function remove(path, body, opts) {
   );
 }
 
+// src/shared/lexorank/index.ts
+var lexorank_exports = {};
+__export(lexorank_exports, {
+  checkBalance: () => checkBalance,
+  createOrderStr: () => createOrderStr,
+  createRebalancedOrderList: () => createRebalancedOrderList,
+  rebalance: () => rebalance,
+  sortByOrder: () => sortByOrder
+});
+
+// src/shared/lexorank/literals.ts
+var LOWER_BOUND = 96;
+var UPPER_BOUND = 123;
+var CHAR_A = 97;
+var CHAR_Z = 122;
+var ALPHABET_SIZE = 26;
+var DISTRIBUTION_TABLE = [
+  0,
+  4096,
+  65792,
+  528416,
+  1081872,
+  2167048,
+  2376776,
+  4756004,
+  4794660,
+  5411476,
+  9775442,
+  11097386,
+  11184810,
+  22369621
+];
+
+// src/shared/lexorank/fns.ts
+var stripTrailingAs = (str) => {
+  let last = str.length - 1;
+  while (str.charAt(last) === "a") --last;
+  return str.slice(0, last + 1);
+};
+var partialAlphabet = (num2) => {
+  let bits = num2 < 13 ? DISTRIBUTION_TABLE[num2] ?? 0 : 33554431 - (DISTRIBUTION_TABLE[25 - num2] ?? 0);
+  const chars = [];
+  for (let i = 1; i < ALPHABET_SIZE; i++, bits >>= 1) {
+    if (bits & 1) chars.push(String.fromCharCode(CHAR_A + i));
+  }
+  return chars;
+};
+
+// src/shared/lexorank/domain.ts
+var createOrderStr = (prev = "", next = "") => {
+  let p;
+  let n;
+  let pos;
+  let str;
+  for (pos = 0; p === n; pos++) {
+    p = pos < prev.length ? prev.charCodeAt(pos) : LOWER_BOUND;
+    n = pos < next.length ? next.charCodeAt(pos) : UPPER_BOUND;
+  }
+  str = prev.slice(0, pos - 1);
+  if (p === LOWER_BOUND) {
+    while (n === CHAR_A) {
+      n = pos < next.length ? next.charCodeAt(pos++) : UPPER_BOUND;
+      str += "a";
+    }
+    if (n === CHAR_A + 1) {
+      str += "a";
+      n = UPPER_BOUND;
+    }
+  } else if (p !== void 0 && n !== void 0 && p + 1 === n) {
+    str += String.fromCharCode(p);
+    n = UPPER_BOUND;
+    while ((p = pos < prev.length ? prev.charCodeAt(pos++) : LOWER_BOUND) === CHAR_Z) {
+      str += "z";
+    }
+  }
+  return str + String.fromCharCode(
+    Math.ceil(((p ?? LOWER_BOUND) + (n ?? UPPER_BOUND)) / 2)
+  );
+};
+var createRebalancedOrderList = (num2) => {
+  const chars = Math.floor(Math.log(num2) / Math.log(ALPHABET_SIZE)) + 1;
+  const prev = Math.pow(ALPHABET_SIZE, chars - 1);
+  const ratio = chars > 1 ? (num2 + 1 - prev) / prev : num2;
+  const part = Math.floor(ratio);
+  const alpha = [partialAlphabet(part), partialAlphabet(part + 1)];
+  const leapStep = ratio % 1;
+  let leapTotal = 0.5;
+  let first = true;
+  const strings = [];
+  const generate = (full, str) => {
+    if (full) {
+      for (let i = 0; i < ALPHABET_SIZE; i++) {
+        generate(full - 1, str + String.fromCharCode(CHAR_A + i));
+      }
+    } else {
+      if (!first) strings.push(stripTrailingAs(str));
+      else first = false;
+      const leap = Math.floor(leapTotal += leapStep);
+      leapTotal %= 1;
+      for (let i = 0; i < part + leap; i++) {
+        strings.push(str + (alpha[leap]?.[i] ?? ""));
+      }
+    }
+  };
+  generate(chars - 1, "");
+  return strings;
+};
+var checkBalance = (xs) => {
+  let largestOrderStr = 0;
+  xs.forEach(
+    (x) => largestOrderStr = Math.max(largestOrderStr, x.order.length)
+  );
+  return largestOrderStr > xs.length / 2;
+};
+var rebalance = (xs) => {
+  const rebalancedOrderList = createRebalancedOrderList(xs.length);
+  return xs.map((x, i) => ({ ...x, order: rebalancedOrderList[i] ?? x.order }));
+};
+var sortByOrder = (xs) => xs.toSorted((a, b) => (a.order ?? "").localeCompare(b.order ?? ""));
+
 // src/server/os/index.ts
 var os_exports = {};
 __export(os_exports, {
@@ -2794,6 +2914,7 @@ exports.File = file_exports;
 exports.Flow = flow_exports;
 exports.Int = int_exports;
 exports.Lambda = lambda_exports;
+exports.LexoRank = lexorank_exports;
 exports.List = list_exports;
 exports.Log = log_exports;
 exports.Money = money_exports;

package/dist/server/index.d.ts

@@ -8,6 +8,7 @@ export * as Flow from "../shared/flow";
 export * as Random from "../shared/random";
 export * as Log from "../shared/log";
 export * as Api from "../shared/api";
+export * as LexoRank from "../shared/lexorank";
 export * as Os from "./os";
 export * as File from "./file";
 export * as Lambda from "./aws/lambda";

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AAGrC,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAC;AAG/C,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC"}

package/dist/server/index.js

@@ -1093,6 +1093,126 @@ function remove(path, body, opts) {
   );
 }
 
+// src/shared/lexorank/index.ts
+var lexorank_exports = {};
+__export(lexorank_exports, {
+  checkBalance: () => checkBalance,
+  createOrderStr: () => createOrderStr,
+  createRebalancedOrderList: () => createRebalancedOrderList,
+  rebalance: () => rebalance,
+  sortByOrder: () => sortByOrder
+});
+
+// src/shared/lexorank/literals.ts
+var LOWER_BOUND = 96;
+var UPPER_BOUND = 123;
+var CHAR_A = 97;
+var CHAR_Z = 122;
+var ALPHABET_SIZE = 26;
+var DISTRIBUTION_TABLE = [
+  0,
+  4096,
+  65792,
+  528416,
+  1081872,
+  2167048,
+  2376776,
+  4756004,
+  4794660,
+  5411476,
+  9775442,
+  11097386,
+  11184810,
+  22369621
+];
+
+// src/shared/lexorank/fns.ts
+var stripTrailingAs = (str) => {
+  let last = str.length - 1;
+  while (str.charAt(last) === "a") --last;
+  return str.slice(0, last + 1);
+};
+var partialAlphabet = (num2) => {
+  let bits = num2 < 13 ? DISTRIBUTION_TABLE[num2] ?? 0 : 33554431 - (DISTRIBUTION_TABLE[25 - num2] ?? 0);
+  const chars = [];
+  for (let i = 1; i < ALPHABET_SIZE; i++, bits >>= 1) {
+    if (bits & 1) chars.push(String.fromCharCode(CHAR_A + i));
+  }
+  return chars;
+};
+
+// src/shared/lexorank/domain.ts
+var createOrderStr = (prev = "", next = "") => {
+  let p;
+  let n;
+  let pos;
+  let str;
+  for (pos = 0; p === n; pos++) {
+    p = pos < prev.length ? prev.charCodeAt(pos) : LOWER_BOUND;
+    n = pos < next.length ? next.charCodeAt(pos) : UPPER_BOUND;
+  }
+  str = prev.slice(0, pos - 1);
+  if (p === LOWER_BOUND) {
+    while (n === CHAR_A) {
+      n = pos < next.length ? next.charCodeAt(pos++) : UPPER_BOUND;
+      str += "a";
+    }
+    if (n === CHAR_A + 1) {
+      str += "a";
+      n = UPPER_BOUND;
+    }
+  } else if (p !== void 0 && n !== void 0 && p + 1 === n) {
+    str += String.fromCharCode(p);
+    n = UPPER_BOUND;
+    while ((p = pos < prev.length ? prev.charCodeAt(pos++) : LOWER_BOUND) === CHAR_Z) {
+      str += "z";
+    }
+  }
+  return str + String.fromCharCode(
+    Math.ceil(((p ?? LOWER_BOUND) + (n ?? UPPER_BOUND)) / 2)
+  );
+};
+var createRebalancedOrderList = (num2) => {
+  const chars = Math.floor(Math.log(num2) / Math.log(ALPHABET_SIZE)) + 1;
+  const prev = Math.pow(ALPHABET_SIZE, chars - 1);
+  const ratio = chars > 1 ? (num2 + 1 - prev) / prev : num2;
+  const part = Math.floor(ratio);
+  const alpha = [partialAlphabet(part), partialAlphabet(part + 1)];
+  const leapStep = ratio % 1;
+  let leapTotal = 0.5;
+  let first = true;
+  const strings = [];
+  const generate = (full, str) => {
+    if (full) {
+      for (let i = 0; i < ALPHABET_SIZE; i++) {
+        generate(full - 1, str + String.fromCharCode(CHAR_A + i));
+      }
+    } else {
+      if (!first) strings.push(stripTrailingAs(str));
+      else first = false;
+      const leap = Math.floor(leapTotal += leapStep);
+      leapTotal %= 1;
+      for (let i = 0; i < part + leap; i++) {
+        strings.push(str + (alpha[leap]?.[i] ?? ""));
+      }
+    }
+  };
+  generate(chars - 1, "");
+  return strings;
+};
+var checkBalance = (xs) => {
+  let largestOrderStr = 0;
+  xs.forEach(
+    (x) => largestOrderStr = Math.max(largestOrderStr, x.order.length)
+  );
+  return largestOrderStr > xs.length / 2;
+};
+var rebalance = (xs) => {
+  const rebalancedOrderList = createRebalancedOrderList(xs.length);
+  return xs.map((x, i) => ({ ...x, order: rebalancedOrderList[i] ?? x.order }));
+};
+var sortByOrder = (xs) => xs.toSorted((a, b) => (a.order ?? "").localeCompare(b.order ?? ""));
+
 // src/server/os/index.ts
 var os_exports = {};
 __export(os_exports, {
@@ -2779,4 +2899,4 @@ var recordsFromSqs = (body) => {
   }
 };
 
-export { api_exports as Api, ddb_exports as DDB, dict_exports as Dict, file_exports as File, flow_exports as Flow, int_exports as Int, lambda_exports as Lambda, list_exports as List, log_exports as Log, money_exports as Money, os_exports as Os, random_exports as Random, s3_exports as S3, ses_exports as SES, sns_exports as SNS, sqs_exports as SQS, str_exports as Str, time_exports as Time };
+export { api_exports as Api, ddb_exports as DDB, dict_exports as Dict, file_exports as File, flow_exports as Flow, int_exports as Int, lambda_exports as Lambda, lexorank_exports as LexoRank, list_exports as List, log_exports as Log, money_exports as Money, os_exports as Os, random_exports as Random, s3_exports as S3, ses_exports as SES, sns_exports as SNS, sqs_exports as SQS, str_exports as Str, time_exports as Time };

package/dist/shared/lexorank/domain.d.ts

@@ -0,0 +1,71 @@
+import * as _t from "./types";
+/**
+ * Generate a new sort key between two adjacent items.
+ *
+ * Given the order strings of the previous and next items, produces a
+ * string that sorts lexicographically between them. Pass empty strings
+ * for boundaries (insert at start or end).
+ *
+ * Algorithm uses lowercase a-z (char codes 96-123) as the alphabet:
+ * - 96 = boundary before 'a'
+ * - 123 = boundary after 'z'
+ *
+ * @example
+ * createOrderStr("b", "d")   // "c"
+ * createOrderStr("", "b")    // "a" (or similar, insert at start)
+ * createOrderStr("n", "")    // "t" (or similar, insert at end)
+ * createOrderStr("az", "b")  // "an" (midpoint between "az" and "b")
+ */
+export declare const createOrderStr: (prev?: string, next?: string) => string;
+/**
+ * Generate evenly-spaced order keys for a list of a given size.
+ *
+ * Used for initial list creation and periodic rebalancing. Produces
+ * `num` strings that are roughly evenly distributed across the a-z
+ * alphabet space, minimizing future string growth.
+ *
+ * @example
+ * createRebalancedOrderList(3)  // ["i", "r", "z"] (roughly evenly spaced)
+ * createRebalancedOrderList(5)  // ["e", "j", "o", "t", "y"]
+ */
+export declare const createRebalancedOrderList: (num: number) => string[];
+/**
+ * Check if the order strings in a list need rebalancing.
+ *
+ * Returns true when the longest order string exceeds half the list size.
+ * This indicates too many consecutive edge insertions have caused string
+ * growth. Rebalancing is rare in normal usage patterns.
+ *
+ * @example
+ * checkBalance([{ order: "b" }, { order: "n" }])       // false (1 < 1)
+ * checkBalance([{ order: "aaaaax" }, { order: "b" }])   // true  (6 > 1)
+ */
+export declare const checkBalance: <T extends _t.Ordered>(xs: T[]) => boolean;
+/**
+ * Rebalance a list by recomputing evenly-spaced order keys for every item.
+ *
+ * Eliminates long order strings caused by repeated edge insertions.
+ * Returns new items with fresh `order` values. Does not mutate input.
+ *
+ * @example
+ * const items = [
+ *   { id: "a", order: "aaaaax" },
+ *   { id: "b", order: "b" },
+ *   { id: "c", order: "n" },
+ * ];
+ * rebalance(items);
+ * // [{ id: "a", order: "i" }, { id: "b", order: "r" }, { id: "c", order: "z" }]
+ */
+export declare const rebalance: <T extends _t.Ordered>(xs: T[]) => (T & {
+    order: string;
+})[];
+/**
+ * Sort items by their lexicographic order strings.
+ *
+ * Returns a new sorted array (immutable). Items without an order
+ * field sort to the beginning.
+ */
+export declare const sortByOrder: <T extends {
+    order?: string;
+}>(xs: T[]) => T[];
+//# sourceMappingURL=domain.d.ts.map

package/dist/shared/lexorank/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/domain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAI9B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAI,aAAS,EAAE,aAAS,WA0ClD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,GAAI,KAAK,MAAM,aAiCpD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,YAMzD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE;;IAGtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,CAAC,EAAE,QACI,CAAC"}

package/dist/shared/lexorank/fns.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strip trailing 'a' characters from a string.
+ *
+ * During order list generation, intermediate strings can end with runs
+ * of 'a's that add length without information. Stripping them produces
+ * shorter, cleaner keys that still sort correctly.
+ *
+ * @example
+ * stripTrailingAs("naaa") // "n"
+ * stripTrailingAs("abc")  // "abc"
+ * stripTrailingAs("a")    // ""
+ */
+export declare const stripTrailingAs: (str: string) => string;
+/**
+ * Generate a partial alphabet for evenly distributing keys.
+ *
+ * Uses a bit-packed lookup table to select well-distributed
+ * characters from the a-z range based on the desired count.
+ * For counts >= 13, the table mirrors to cover the full range.
+ *
+ * @example
+ * partialAlphabet(3) // ["d", "n", "x"] (roughly evenly spaced)
+ */
+export declare const partialAlphabet: (num: number) => string[];
+//# sourceMappingURL=fns.d.ts.map

package/dist/shared/lexorank/fns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fns.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/fns.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,WAI1C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,aAW1C,CAAC"}

package/dist/shared/lexorank/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LexoRank Ordering
+ *
+ * Lexicographic string-based ordering for collection items.
+ * Enables O(1) reorder operations: moving an item between two others
+ * generates a new order string between their existing orders.
+ *
+ * Key functions:
+ * - `createOrderStr(prev, next)` - Generate key between two adjacent items
+ * - `createRebalancedOrderList(num)` - Generate evenly-spaced keys for a list
+ * - `checkBalance(xs)` - Detect when rebalancing is needed
+ * - `rebalance(xs)` - Recompute all orders
+ * - `sortByOrder(xs)` - Sort items by lexicographic order
+ */
+export type * from "./types";
+export * from "./domain";
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/lexorank/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,mBAAmB,SAAS,CAAC;AAC7B,cAAc,UAAU,CAAC"}

package/dist/shared/lexorank/literals.d.ts

@@ -0,0 +1,20 @@
+/** Char code for the lower bound sentinel (one below 'a') */
+export declare const LOWER_BOUND = 96;
+/** Char code for the upper bound sentinel (one above 'z') */
+export declare const UPPER_BOUND = 123;
+/** Char code for 'a' — first character in the usable alphabet */
+export declare const CHAR_A = 97;
+/** Char code for 'z' — last character in the usable alphabet */
+export declare const CHAR_Z = 122;
+/** Size of the a-z alphabet */
+export declare const ALPHABET_SIZE = 26;
+/**
+ * Bit-packed lookup table for selecting well-distributed characters
+ * from the a-z range when generating evenly-spaced order keys.
+ *
+ * Each entry encodes which of the 25 non-'a' characters to include
+ * when distributing `n` keys across the alphabet. For n >= 13, the
+ * table is mirrored using a 25-bit mask (2^25 - 1 = 33554431).
+ */
+export declare const DISTRIBUTION_TABLE: readonly [0, 4096, 65792, 528416, 1081872, 2167048, 2376776, 4756004, 4794660, 5411476, 9775442, 11097386, 11184810, 22369621];
+//# sourceMappingURL=literals.d.ts.map

package/dist/shared/lexorank/literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/literals.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,6DAA6D;AAC7D,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,iEAAiE;AACjE,eAAO,MAAM,MAAM,KAAK,CAAC;AAEzB,gEAAgE;AAChE,eAAO,MAAM,MAAM,MAAM,CAAC;AAE1B,+BAA+B;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,gIAGrB,CAAC"}

package/dist/shared/lexorank/types.d.ts

@@ -0,0 +1,5 @@
+/** Item with a lexicographic order field */
+export interface Ordered {
+    order: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/lexorank/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/shared/lexorank/types.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;CACf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qstd",
-  "version": "0.3.84",
+  "version": "0.3.86",
   "description": "Standard Block component and utilities library with Panda CSS",
   "author": "malin1",
   "license": "MIT",