fraci/dist/dev/chunk-VEBTP4GL.js

Fractional indexing that's robust, performant, and secure, with first-class support for Drizzle ORM and Prisma ORM.

// src/lib/errors.ts
var c = class extends Error {
  constructor(r, t) {
    super(`[${r}] ${t}`);
    this.code = r;
    this.message = t;
    this.name = "FraciError";
  }
  name;
};
function En(n) {
  return n instanceof c;
}
function hn(n) {
  return n instanceof c ? n.code : void 0;
}

// src/lib/decimal-binary.ts
var P = new Uint8Array([128, 0]), yn = new Uint8Array([127, 255]);
function B(n, e) {
  let r = Math.min(n.length, e.length), t = 0;
  for (let o = 0; !t && o < r; o++)
    t = n[o] - e[o];
  return t || n.length - e.length;
}
function I(n, e) {
  let r = new Uint8Array(n.length + e.length);
  return r.set(n), r.set(e, n.length), r;
}
function G(n) {
  let [e] = n;
  return e - (e >= 128 ? 127 : 128);
}
function v(n) {
  return n + (n < 0 ? 128 : 127);
}
function R(n) {
  return n.length === 129 && n.every((e) => e === 0);
}
function b(n) {
  let e = Math.abs(G(n)) + 1;
  if (!(Number.isNaN(e) || n.length < e))
    return [n.subarray(0, e), n.subarray(e)];
}
function V(n) {
  if (!n.length)
    return;
  let e = G(n), r = n.slice(0, Math.abs(e) + 1);
  for (let i = r.length - 1; i >= 1; i--)
    if (r[i]++ < 255)
      return r;
  if (e === -1)
    return P.slice();
  let t = e + 1;
  if (t > 128)
    return null;
  let o = new Uint8Array(Math.abs(t) + 1);
  return o[0] = v(t), o;
}
function z(n) {
  let e = G(n);
  if (Number.isNaN(e))
    return;
  let r = n.slice(0, Math.abs(e) + 1);
  for (let i = r.length - 1; i >= 1; i--)
    if (r[i]--)
      return r;
  if (e === 1)
    return yn.slice();
  let t = e - 1;
  if (t < -128)
    return null;
  let o = new Uint8Array(Math.abs(t) + 1).fill(255);
  return o[0] = v(t), o;
}
function x(n, e) {
  if (e != null && B(n, e) >= 0)
    return;
  if (e) {
    let a = e.findIndex((l, s) => l !== (n[s] ?? 0));
    if (a > 0) {
      let l = x(
        n.subarray(a),
        e.subarray(a)
      );
      return l ? I(e.subarray(0, a), l) : void 0;
    }
  }
  let r = n[0] ?? 0, t = e ? e[0] : 256;
  if (t == null)
    return;
  if (r + 1 !== t) {
    let a = r + t >> 1;
    return new Uint8Array([a]);
  }
  if (e && e.length > 1)
    return new Uint8Array([e[0]]);
  let o = x(n.subarray(1), null);
  if (!o)
    return;
  let i = new Uint8Array(1 + o.length);
  return i[0] = r, i.set(o, 1), i;
}

// src/lib/decimal-string.ts
function k(n, e) {
  return e.get(n[0]);
}
function w(n, e) {
  let r = Math.abs(k(n, e) ?? 0) + 1;
  if (!(r < 2 || n.length < r))
    return [n.slice(0, r), n.slice(r)];
}
function J(n, e) {
  return e.get(1) + n[0];
}
function Q(n, e) {
  let r = Math.min(...Array.from(e.keys()));
  return `${e.get(r)}${n[0].repeat(Math.abs(r))}`;
}
function Z(n, e, r, t, o) {
  let i = k(n, o);
  if (!i)
    return;
  let a = e[0], [l, ...s] = n.slice(0, Math.abs(i) + 1);
  for (let g = s.length - 1; g >= 0; g--) {
    let y = r.get(s[g]);
    if (y == null)
      return;
    if (y < e.length - 1)
      return s[g] = e[y + 1], `${l}${s.join("")}`;
    s[g] = a;
  }
  if (i === -1)
    return `${t.get(1)}${a}`;
  let u = i + 1, f = t.get(u);
  return f ? `${f}${a.repeat(Math.abs(u))}` : null;
}
function Y(n, e, r, t, o) {
  let i = k(n, o);
  if (!i)
    return;
  let a = e[e.length - 1], [l, ...s] = n.slice(0, Math.abs(i) + 1);
  for (let g = s.length - 1; g >= 0; g--) {
    let y = r.get(s[g]);
    if (y == null)
      return;
    if (y > 0)
      return s[g] = e[y - 1], `${l}${s.join("")}`;
    s[g] = a;
  }
  if (i === 1)
    return `${t.get(-1)}${a}`;
  let u = i - 1, f = t.get(u);
  return f ? `${f}${a.repeat(Math.abs(u))}` : null;
}
function _(n, e, r, t) {
  if (e != null && e <= n)
    return;
  if (e) {
    let a = n.padEnd(e.length, r[0]), l = Array.prototype.findIndex.call(
      e,
      (s, u) => s !== a[u]
    );
    if (l > 0)
      return `${e.slice(0, l)}${_(
        n.slice(l),
        e.slice(l),
        r,
        t
      )}`;
  }
  let o = n ? t.get(n[0]) : 0, i = e ? t.get(e[0]) : r.length;
  if (!(o == null || i == null)) {
    if (o + 1 !== i) {
      let a = o + i >> 1;
      return r[a];
    }
    return e && e.length > 1 ? e[0] : `${r[o]}${_(
      n.slice(1),
      null,
      r,
      t
    )}`;
  }
}

// src/lib/fractional-indexing-binary.ts
function N(n) {
  return n?.constructor.name === "Buffer" ? new Uint8Array(n.buffer, n.byteOffset, n.length) : n;
}
function D(n) {
  if (!n.length || R(n))
    return !1;
  let e = b(n);
  if (!e)
    return !1;
  let [, r] = e;
  return r?.at(-1) !== 0;
}
function E(n) {
  if (n === void 0)
    throw console.error(
      "FraciError: [INTERNAL_ERROR] Unexpected undefined. Please file an issue to report this error."
    ), new c("INTERNAL_ERROR", "Unexpected undefined");
  return n;
}
function M(n, e) {
  if (!n) {
    if (!e)
      return P.slice();
    let [l, s] = E(b(e));
    if (R(l))
      return I(
        l,
        E(x(new Uint8Array(), s))
      );
    if (s.length)
      return l.slice();
    let u = E(
      z(l)
    );
    if (!R(u))
      return u;
    let f = new Uint8Array(u.length + 1);
    return f.set(u), f[u.length] = 255, f;
  }
  if (!e) {
    let l = E(b(n)), [s, u] = l, f = E(V(s));
    return f || I(s, E(x(u, null)));
  }
  let [r, t] = E(b(n)), [o, i] = E(b(e));
  if (!B(r, o))
    return I(
      r,
      E(x(t, i))
    );
  let a = E(V(r));
  return a && B(a, o) ? (
    // 1. If incrementing a's integer doesn't reach b's integer,
    // we can use the incremented value (shorter key)
    a
  ) : (
    // 2. If incrementing a's integer equals b's integer or we can't increment,
    // we need to use a's integer with a fractional part that sorts after a's fractional part
    I(r, E(x(t, null)))
  );
}
function nn(n, e) {
  return n != null && !D(n) || e != null && !D(e) || n != null && e != null && B(n, e) >= 0 ? void 0 : M(N(n), N(e));
}
function H(n, e, r) {
  if (r < 1)
    return [];
  if (r === 1)
    return [M(n, e)];
  if (e == null) {
    let i = n;
    return Array.from(
      { length: r },
      () => i = M(i, e)
    );
  }
  if (n == null) {
    let i = e;
    return Array.from(
      { length: r },
      () => i = M(n, i)
    ).reverse();
  }
  let t = r >> 1, o = M(n, e);
  return [
    ...H(n, o, t),
    o,
    ...H(o, e, r - t - 1)
  ];
}
function en(n, e, r) {
  return n != null && !D(n) || e != null && !D(e) || n != null && e != null && B(n, e) >= 0 ? void 0 : H(N(n), N(e), r);
}
function j(n) {
  let e = [];
  for (; n > 0; )
    e.push(n & 255), n >>= 8;
  return new Uint8Array(e);
}

// src/lib/fractional-indexing-string.ts
function L(n, e, r, t, o) {
  if (!n || n === o)
    return !1;
  let i = w(n, t);
  if (!i)
    return !1;
  let [a, l] = i;
  if (l.endsWith(e[0]))
    return !1;
  for (let s of a.slice(1))
    if (!r.has(s))
      return !1;
  for (let s of l)
    if (!r.has(s))
      return !1;
  return !0;
}
function h(n) {
  if (n === void 0)
    throw console.error(
      "FraciError: [INTERNAL_ERROR] Unexpected undefined. Please file an issue to report this error."
    ), new c("INTERNAL_ERROR", "Unexpected undefined");
  return n;
}
function T(n, e, r, t, o, i, a) {
  if (!n) {
    if (!e)
      return J(r, o);
    let [d, m] = h(w(e, i));
    if (d === a)
      return `${d}${h(
        _("", m, r, t)
      )}`;
    if (m)
      return d;
    let p = h(
      Y(
        d,
        r,
        t,
        o,
        i
      )
    );
    return p === a ? `${p}${r[r.length - 1]}` : p;
  }
  if (!e) {
    let d = h(w(n, i)), [m, p] = d, F = h(
      Z(
        m,
        r,
        t,
        o,
        i
      )
    );
    return F !== null ? F : `${m}${h(
      _(p, null, r, t)
    )}`;
  }
  let l = h(w(n, i)), s = h(w(e, i)), [u, f] = l, [g, y] = s;
  if (u === g)
    return `${u}${h(
      _(f, y, r, t)
    )}`;
  let A = h(
    Z(
      u,
      r,
      t,
      o,
      i
    )
  );
  return A !== null && A !== g ? (
    // 1. If incrementing a's integer doesn't reach b's integer,
    // we can use the incremented value (shorter key)
    A
  ) : (
    // 2. If incrementing a's integer equals b's integer or we can't increment,
    // we need to use a's integer with a fractional part that sorts after a's fractional part
    `${u}${h(
      _(f, null, r, t)
    )}`
  );
}
function rn(n, e, r, t, o, i, a) {
  return n != null && !L(
    n,
    r,
    t,
    i,
    a
  ) || e != null && !L(
    e,
    r,
    t,
    i,
    a
  ) || n != null && e != null && e <= n ? void 0 : T(
    n,
    e,
    r,
    t,
    o,
    i,
    a
  );
}
function q(n, e, r, ...t) {
  if (r < 1)
    return [];
  if (r === 1)
    return [T(n, e, ...t)];
  if (e == null) {
    let a = n;
    return Array.from(
      { length: r },
      () => a = T(a, e, ...t)
    );
  }
  if (n == null) {
    let a = e;
    return Array.from(
      { length: r },
      () => a = T(n, a, ...t)
    ).reverse();
  }
  let o = r >> 1, i = T(n, e, ...t);
  return [
    ...q(n, i, o, ...t),
    i,
    ...q(i, e, r - o - 1, ...t)
  ];
}
function tn(n, e, r, t, o, i, a, l) {
  return n != null && !L(
    n,
    t,
    o,
    a,
    l
  ) || e != null && !L(
    e,
    t,
    o,
    a,
    l
  ) || n != null && e != null && e <= n ? void 0 : q(
    n,
    e,
    r,
    t,
    o,
    i,
    a,
    l
  );
}
function W(n, e) {
  let r = e.length, t = "";
  for (; n > 0; )
    t += e[n % r], n = Math.floor(n / r);
  return t;
}

// src/lib/utils.ts
var on = "INITIALIZATION_FAILED";
function an(n) {
  let e = n.split("");
  if (e.length < 4)
    throw new c(
      on,
      "Base string must have at least 4 unique characters"
    );
  let r = -1;
  for (let t of e) {
    let o = t.charCodeAt(0);
    if (o <= r)
      throw new c(
        on,
        "Base string characters must be unique and in ascending order"
      );
    r = o;
  }
  return e;
}
function ln(n) {
  let e = an(n);
  return [e, new Map(e.map((r, t) => [r, t]))];
}
function sn(n) {
  let e = an(n), r = e.length >> 1, t = e.map(
    (o, i) => [
      i < r ? (
        // For characters in the first half, assign negative values starting from -1
        i - r
      ) : (
        // For characters in the second half, assign positive values starting from 1
        i - r + 1
      ),
      // This maps to 1, 2, 3, etc. (skipping 0)
      o
    ]
  );
  return [
    new Map(t),
    new Map(t.map(([o, i]) => [i, o]))
  ];
}

// src/factory.ts
var cn = 50, fn = 5, O = "INVALID_FRACTIONAL_INDEX", U = "Invalid indices provided", S = "MAX_LENGTH_EXCEEDED", X = "Exceeded maximum length", C = "MAX_RETRIES_EXCEEDED", $ = "Exceeded maximum retries";
function Sn() {
  return /* @__PURE__ */ new Map();
}
function un(n, e, r) {
  if (!n)
    return r();
  let t = n.get(e);
  return t === void 0 && (t = r(), n.set(e, t)), t;
}
function K(n, e, r) {
  console.error(
    `FraciError: [INVALID_FRACTIONAL_INDEX] ${U}. a = ${n}, b = ${e}, skip = ${r}
Make sure that
- Fractional indices generated by the same fraci instance with the same configuration are being used as-is
- Indices in different groups have not been mixed up
- a (the first argument item) comes before b (the second argument item) in the group
File an issue if you use the library correctly and still encounter this error.`
  );
}
function dn({
  maxLength: n = cn,
  maxRetries: e = fn
} = {}) {
  return {
    base: { type: "binary" },
    *generateKeyBetween(r, t, o = 0) {
      let i = nn(r, t);
      if (!i)
        throw K(r, t, o), new c(
          O,
          U
        );
      for (let a = 0; a < e; a++) {
        let l = I(i, j(a + o));
        if (l.length > n)
          throw new c(
            S,
            X
          );
        yield l;
      }
      throw new c(
        C,
        $
      );
    },
    *generateNKeysBetween(r, t, o, i = 0) {
      let a = en(r, t, o);
      if (!a)
        throw K(r, t, i), new c(
          O,
          U
        );
      let l = a.reduce((s, u) => Math.max(s, u.length), 0);
      for (let s = 0; s < e; s++) {
        let u = j(s + i);
        if (l + u.length > n)
          throw new c(
            S,
            X
          );
        yield a.map((f) => I(f, u));
      }
      throw new c(
        C,
        $
      );
    }
  };
}
function pn({
  lengthBase: n,
  digitBase: e,
  maxLength: r = cn,
  maxRetries: t = fn
}, o) {
  let [i, a] = un(
    o,
    `L${n}`,
    sn.bind(null, n)
  ), [l, s] = un(
    o,
    `D${e}`,
    ln.bind(null, e)
  ), u = Q(l, i);
  return {
    base: {
      type: "string",
      lengthBase: n,
      digitBase: e
    },
    *generateKeyBetween(f, g, y = 0) {
      let A = rn(
        f,
        g,
        l,
        s,
        i,
        a,
        u
      );
      if (!A)
        throw K(f, g, y), new c(
          O,
          U
        );
      for (let d = 0; d < t; d++) {
        let m = `${A}${W(d + y, l)}`;
        if (m.length > r)
          throw new c(
            S,
            X
          );
        yield m;
      }
      throw new c(
        C,
        $
      );
    },
    *generateNKeysBetween(f, g, y, A = 0) {
      let d = tn(
        f,
        g,
        y,
        l,
        s,
        i,
        a,
        u
      );
      if (!d)
        throw K(f, g, A), new c(
          O,
          U
        );
      let m = d.reduce((p, F) => Math.max(p, F.length), 0);
      for (let p = 0; p < t; p++) {
        let F = W(p + A, l);
        if (m + F.length > r)
          throw new c(
            S,
            X
          );
        yield d.map((gn) => `${gn}${F}`);
      }
      throw new c(
        C,
        $
      );
    }
  };
}
function Xn(n, e) {
  return n.type === "binary" ? (e && console.warn("Fraci: Cache is not used for binary base"), dn(n)) : pn(n, e);
}

export {
  c as a,
  En as b,
  hn as c,
  cn as d,
  fn as e,
  Sn as f,
  dn as g,
  pn as h,
  Xn as i
};
//# sourceMappingURL=chunk-VEBTP4GL.js.map