icechunk-js 0.4.0 → 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs CHANGED
@@ -352,6 +352,17 @@ var SnapshotInfo = class _SnapshotInfo {
352
352
  const offset = this.bb.__offset(this.bb_pos, 12);
353
353
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
354
354
  }
355
+ prunedAncestorTxLogs(index, obj) {
356
+ const offset = this.bb.__offset(this.bb_pos, 14);
357
+ return offset ? (obj || new ObjectId12()).__init(
358
+ this.bb.__vector(this.bb_pos + offset) + index * 12,
359
+ this.bb
360
+ ) : null;
361
+ }
362
+ prunedAncestorTxLogsLength() {
363
+ const offset = this.bb.__offset(this.bb_pos, 14);
364
+ return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
365
+ }
355
366
  };
356
367
 
357
368
  // src/format/flatbuffers/generated/update.ts
@@ -559,8 +570,587 @@ var Repo = class _Repo {
559
570
  }
560
571
  };
561
572
 
562
- // src/format/flatbuffers/repo-parser.ts
563
- var import_fzstd = require("fzstd");
573
+ // src/vendor/fzstd/index.ts
574
+ var ab = ArrayBuffer;
575
+ var u8 = Uint8Array;
576
+ var u16 = Uint16Array;
577
+ var i16 = Int16Array;
578
+ var i32 = Int32Array;
579
+ var slc = (v, s, e) => {
580
+ if (u8.prototype.slice) return u8.prototype.slice.call(v, s, e);
581
+ if (s == null || s < 0) s = 0;
582
+ if (e == null || e > v.length) e = v.length;
583
+ const n = new u8(e - s);
584
+ n.set(v.subarray(s, e));
585
+ return n;
586
+ };
587
+ var fill = (v, n, s, e) => {
588
+ if (u8.prototype.fill) return u8.prototype.fill.call(v, n, s, e);
589
+ if (s == null || s < 0) s = 0;
590
+ if (e == null || e > v.length) e = v.length;
591
+ for (; s < e; ++s) v[s] = n;
592
+ return v;
593
+ };
594
+ var cpw = (v, t, s, e) => {
595
+ if (u8.prototype.copyWithin) return u8.prototype.copyWithin.call(v, t, s, e);
596
+ if (s == null || s < 0) s = 0;
597
+ if (e == null || e > v.length) e = v.length;
598
+ while (s < e) {
599
+ v[t++] = v[s++];
600
+ }
601
+ };
602
+ var ec = [
603
+ "invalid zstd data",
604
+ "window size too large (>2046MB)",
605
+ "invalid block type",
606
+ "FSE accuracy too high",
607
+ "match distance too far back",
608
+ "unexpected EOF",
609
+ "wrong dictionary"
610
+ ];
611
+ var err = (ind, msg, nt) => {
612
+ const e = new Error(msg || ec[ind]);
613
+ e.code = ind;
614
+ if (Error.captureStackTrace) Error.captureStackTrace(e, err);
615
+ if (!nt) throw e;
616
+ return e;
617
+ };
618
+ var rb = (d, b, n) => {
619
+ let i = 0, o = 0;
620
+ for (; i < n; ++i) o |= d[b++] << (i << 3);
621
+ return o;
622
+ };
623
+ var b4 = (d, b) => (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
624
+ var rdic = (dic, st) => {
625
+ if (b4(dic, 0) == 3962610743) {
626
+ if (st.d && st.d !== b4(dic, 4)) err(6);
627
+ let bt = 8;
628
+ [bt, st.h] = rhu(dic, bt);
629
+ let mlt, olt, llt;
630
+ [bt, olt] = rfse(dic, bt, 8);
631
+ [bt, mlt] = rfse(dic, bt, 9);
632
+ [bt, llt] = rfse(dic, bt, 9);
633
+ st.t = [mlt, olt, llt];
634
+ st.o = new i32([b4(dic, bt), b4(dic, bt + 4), b4(dic, bt + 8)]);
635
+ dic = dic.subarray(bt + 12);
636
+ }
637
+ const wl = Math.max(dic.length, st.u ? Math.min(st.e, dic.length + st.u) : st.e);
638
+ st.w = new u8(wl);
639
+ st.w.set(dic, wl - dic.length);
640
+ st.e = wl;
641
+ };
642
+ var rzfh = (dat, w) => {
643
+ const n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
644
+ if (n3 == 3126568 && dat[3] == 253) {
645
+ const flg = dat[4];
646
+ const ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
647
+ if (flg & 8) err(0);
648
+ let bt = 6 - ss;
649
+ const db = df == 3 ? 4 : df;
650
+ const di = rb(dat, bt, db);
651
+ bt += db;
652
+ const fsb = fcf ? 1 << fcf : ss;
653
+ const fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
654
+ let ws = fss;
655
+ if (!ss) {
656
+ const wb = 1 << 10 + (dat[5] >> 3);
657
+ ws = wb + (wb >> 3) * (dat[5] & 7);
658
+ }
659
+ if (ws > 2145386496) err(1);
660
+ const buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
661
+ buf[0] = 1, buf[4] = 4, buf[8] = 8;
662
+ return {
663
+ b: bt + fsb,
664
+ y: 0,
665
+ l: 0,
666
+ d: di,
667
+ w: w && w != 1 ? w : buf.subarray(12),
668
+ e: ws,
669
+ o: new i32(buf.buffer, 0, 3),
670
+ u: fss,
671
+ c: cc,
672
+ m: Math.min(131072, ws)
673
+ };
674
+ } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
675
+ return b4(dat, 4) + 8;
676
+ }
677
+ err(0);
678
+ };
679
+ var msb = (val) => {
680
+ let bits = 0;
681
+ for (; 1 << bits <= val; ++bits) ;
682
+ return bits - 1;
683
+ };
684
+ var rfse = (dat, bt, mal) => {
685
+ let tpos = (bt << 3) + 4;
686
+ const al = (dat[bt] & 15) + 5;
687
+ if (al > mal) err(3);
688
+ const sz = 1 << al;
689
+ let probs = sz, sym = -1, re = -1, i = -1, ht = sz;
690
+ const buf = new ab(512 + (sz << 2));
691
+ const freq = new i16(buf, 0, 256);
692
+ const dstate = new u16(buf, 0, 256);
693
+ const nstate = new u16(buf, 512, sz);
694
+ const bb1 = 512 + (sz << 1);
695
+ const syms = new u8(buf, bb1, sz);
696
+ const nbits = new u8(buf, bb1 + sz);
697
+ while (sym < 255 && probs > 0) {
698
+ const bits = msb(probs + 1);
699
+ const cbt = tpos >> 3;
700
+ const msk = (1 << bits + 1) - 1;
701
+ let val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
702
+ const msk1fb = (1 << bits) - 1;
703
+ const msv = msk - probs - 1;
704
+ const sval = val & msk1fb;
705
+ if (sval < msv) tpos += bits, val = sval;
706
+ else {
707
+ tpos += bits + 1;
708
+ if (val > msk1fb) val -= msv;
709
+ }
710
+ freq[++sym] = --val;
711
+ if (val == -1) {
712
+ probs += val;
713
+ syms[--ht] = sym;
714
+ } else probs -= val;
715
+ if (!val) {
716
+ do {
717
+ const rbt = tpos >> 3;
718
+ re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
719
+ tpos += 2;
720
+ sym += re;
721
+ } while (re == 3);
722
+ }
723
+ }
724
+ if (sym > 255 || probs) err(0);
725
+ let sympos = 0;
726
+ const sstep = (sz >> 1) + (sz >> 3) + 3;
727
+ const smask = sz - 1;
728
+ for (let s = 0; s <= sym; ++s) {
729
+ const sf = freq[s];
730
+ if (sf < 1) {
731
+ dstate[s] = -sf;
732
+ continue;
733
+ }
734
+ for (i = 0; i < sf; ++i) {
735
+ syms[sympos] = s;
736
+ do {
737
+ sympos = sympos + sstep & smask;
738
+ } while (sympos >= ht);
739
+ }
740
+ }
741
+ if (sympos) err(0);
742
+ for (i = 0; i < sz; ++i) {
743
+ const ns = dstate[syms[i]]++;
744
+ const nb = nbits[i] = al - msb(ns);
745
+ nstate[i] = (ns << nb) - sz;
746
+ }
747
+ return [tpos + 7 >> 3, {
748
+ b: al,
749
+ s: syms,
750
+ n: nbits,
751
+ t: nstate
752
+ }];
753
+ };
754
+ var rhu = (dat, bt) => {
755
+ let i = 0, wc = -1;
756
+ const buf = new u8(292), hb = dat[bt];
757
+ const hw = buf.subarray(0, 256);
758
+ const rc = buf.subarray(256, 268);
759
+ const ri = new u16(buf.buffer, 268);
760
+ if (hb < 128) {
761
+ const [ebt, fdt] = rfse(dat, bt + 1, 6);
762
+ bt += hb;
763
+ const epos = ebt << 3;
764
+ const lb = dat[bt];
765
+ if (!lb) err(0);
766
+ let st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
767
+ let fpos = (++bt << 3) - 8 + msb(lb);
768
+ for (; ; ) {
769
+ fpos -= btr1;
770
+ if (fpos < epos) break;
771
+ let cbt = fpos >> 3;
772
+ st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
773
+ hw[++wc] = fdt.s[st1];
774
+ fpos -= btr2;
775
+ if (fpos < epos) break;
776
+ cbt = fpos >> 3;
777
+ st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
778
+ hw[++wc] = fdt.s[st2];
779
+ btr1 = fdt.n[st1];
780
+ st1 = fdt.t[st1];
781
+ btr2 = fdt.n[st2];
782
+ st2 = fdt.t[st2];
783
+ }
784
+ if (++wc > 255) err(0);
785
+ } else {
786
+ wc = hb - 127;
787
+ for (; i < wc; i += 2) {
788
+ const byte = dat[++bt];
789
+ hw[i] = byte >> 4;
790
+ hw[i + 1] = byte & 15;
791
+ }
792
+ ++bt;
793
+ }
794
+ let wes = 0;
795
+ for (i = 0; i < wc; ++i) {
796
+ const wt = hw[i];
797
+ if (wt > 11) err(0);
798
+ wes += wt && 1 << wt - 1;
799
+ }
800
+ const mb = msb(wes) + 1;
801
+ const ts = 1 << mb;
802
+ const rem = ts - wes;
803
+ if (rem & rem - 1) err(0);
804
+ hw[wc++] = msb(rem) + 1;
805
+ for (i = 0; i < wc; ++i) {
806
+ const wt = hw[i];
807
+ ++rc[hw[i] = wt && mb + 1 - wt];
808
+ }
809
+ const hbuf = new u8(ts << 1);
810
+ const syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
811
+ ri[mb] = 0;
812
+ for (i = mb; i > 0; --i) {
813
+ const pv = ri[i];
814
+ fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
815
+ }
816
+ if (ri[0] != ts) err(0);
817
+ for (i = 0; i < wc; ++i) {
818
+ const bits = hw[i];
819
+ if (bits) {
820
+ const code = ri[bits];
821
+ fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
822
+ }
823
+ }
824
+ return [bt, {
825
+ n: nb,
826
+ b: mb,
827
+ s: syms
828
+ }];
829
+ };
830
+ var dllt = rfse(/* @__PURE__ */ new u8([
831
+ 81,
832
+ 16,
833
+ 99,
834
+ 140,
835
+ 49,
836
+ 198,
837
+ 24,
838
+ 99,
839
+ 12,
840
+ 33,
841
+ 196,
842
+ 24,
843
+ 99,
844
+ 102,
845
+ 102,
846
+ 134,
847
+ 70,
848
+ 146,
849
+ 4
850
+ ]), 0, 6)[1];
851
+ var dmlt = rfse(/* @__PURE__ */ new u8([
852
+ 33,
853
+ 20,
854
+ 196,
855
+ 24,
856
+ 99,
857
+ 140,
858
+ 33,
859
+ 132,
860
+ 16,
861
+ 66,
862
+ 8,
863
+ 33,
864
+ 132,
865
+ 16,
866
+ 66,
867
+ 8,
868
+ 33,
869
+ 68,
870
+ 68,
871
+ 68,
872
+ 68,
873
+ 68,
874
+ 68,
875
+ 68,
876
+ 68,
877
+ 36,
878
+ 9
879
+ ]), 0, 6)[1];
880
+ var doct = rfse(/* @__PURE__ */ new u8([
881
+ 32,
882
+ 132,
883
+ 16,
884
+ 66,
885
+ 102,
886
+ 70,
887
+ 68,
888
+ 68,
889
+ 68,
890
+ 68,
891
+ 36,
892
+ 73,
893
+ 2
894
+ ]), 0, 5)[1];
895
+ var b2bl = (b, s) => {
896
+ const len = b.length, bl = new i32(len);
897
+ for (let i = 0; i < len; ++i) {
898
+ bl[i] = s;
899
+ s += 1 << b[i];
900
+ }
901
+ return bl;
902
+ };
903
+ var llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
904
+ 0,
905
+ 0,
906
+ 0,
907
+ 0,
908
+ 16843009,
909
+ 50528770,
910
+ 134678020,
911
+ 202050057,
912
+ 269422093
913
+ ])).buffer, 0, 36);
914
+ var llbl = /* @__PURE__ */ b2bl(llb, 0);
915
+ var mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
916
+ 0,
917
+ 0,
918
+ 0,
919
+ 0,
920
+ 0,
921
+ 0,
922
+ 0,
923
+ 0,
924
+ 16843009,
925
+ 50528770,
926
+ 117769220,
927
+ 185207048,
928
+ 252579084,
929
+ 16
930
+ ])).buffer, 0, 53);
931
+ var mlbl = /* @__PURE__ */ b2bl(mlb, 3);
932
+ var dhu = (dat, out, hu) => {
933
+ const len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
934
+ if (!lb) err(0);
935
+ let st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
936
+ for (; pos > eb && i < ss; ) {
937
+ const cbt = pos >> 3;
938
+ const val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
939
+ st = (st << btr | val) & msk;
940
+ out[++i] = hu.s[st];
941
+ pos -= btr = hu.n[st];
942
+ }
943
+ if (pos != eb || i + 1 != ss) err(0);
944
+ };
945
+ var dhu4 = (dat, out, hu) => {
946
+ let bt = 6;
947
+ const ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
948
+ dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
949
+ dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
950
+ dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
951
+ dhu(dat.subarray(bt), out.subarray(sz3), hu);
952
+ };
953
+ var rzb = (dat, st, out) => {
954
+ let bt = st.b;
955
+ const b0 = dat[bt], btype = b0 >> 1 & 3;
956
+ st.l = b0 & 1;
957
+ const sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
958
+ const ebt = (bt += 3) + sz;
959
+ if (btype == 1) {
960
+ if (bt >= dat.length) return;
961
+ st.b = bt + 1;
962
+ if (out) {
963
+ fill(out, dat[bt], st.y, st.y += sz);
964
+ return out;
965
+ }
966
+ return fill(new u8(sz), dat[bt]);
967
+ }
968
+ if (ebt > dat.length) return;
969
+ if (btype == 0) {
970
+ st.b = ebt;
971
+ if (out) {
972
+ out.set(dat.subarray(bt, ebt), st.y);
973
+ st.y += sz;
974
+ return out;
975
+ }
976
+ return slc(dat, bt, ebt);
977
+ }
978
+ if (btype == 2) {
979
+ const b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
980
+ let lss = b3 >> 4, lcs = 0, s4 = 0;
981
+ if (lbt < 2) {
982
+ if (sf & 1) lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
983
+ else lss = b3 >> 3;
984
+ } else {
985
+ s4 = sf;
986
+ if (sf < 2) lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
987
+ else if (sf == 2) lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
988
+ else lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
989
+ }
990
+ ++bt;
991
+ let buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
992
+ let spl = buf.length - lss;
993
+ if (lbt == 0) buf.set(dat.subarray(bt, bt += lss), spl);
994
+ else if (lbt == 1) fill(buf, dat[bt++], spl);
995
+ else {
996
+ let hu = st.h;
997
+ if (lbt == 2) {
998
+ const hud = rhu(dat, bt);
999
+ lcs += bt - (bt = hud[0]);
1000
+ st.h = hu = hud[1];
1001
+ } else if (!hu) err(0);
1002
+ (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
1003
+ }
1004
+ let ns = dat[bt++];
1005
+ if (ns) {
1006
+ if (ns == 255) ns = (dat[bt++] | dat[bt++] << 8) + 32512;
1007
+ else if (ns > 127) ns = ns - 128 << 8 | dat[bt++];
1008
+ const scm = dat[bt++];
1009
+ if (scm & 3) err(0);
1010
+ const dts = [dmlt, doct, dllt];
1011
+ for (let i = 2; i > -1; --i) {
1012
+ const md = scm >> (i << 1) + 2 & 3;
1013
+ if (md == 1) {
1014
+ const rbuf = new u8([0, 0, dat[bt++]]);
1015
+ dts[i] = {
1016
+ s: rbuf.subarray(2, 3),
1017
+ n: rbuf.subarray(0, 1),
1018
+ t: new u16(rbuf.buffer, 0, 1),
1019
+ b: 0
1020
+ };
1021
+ } else if (md == 2) {
1022
+ [bt, dts[i]] = rfse(dat, bt, 9 - (i & 1));
1023
+ } else if (md == 3) {
1024
+ if (!st.t) err(0);
1025
+ dts[i] = st.t[i];
1026
+ }
1027
+ }
1028
+ const [mlt, oct, llt] = st.t = dts;
1029
+ const lb = dat[ebt - 1];
1030
+ if (!lb) err(0);
1031
+ let spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
1032
+ let lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
1033
+ cbt = (spos -= oct.b) >> 3;
1034
+ let ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
1035
+ cbt = (spos -= mlt.b) >> 3;
1036
+ let mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
1037
+ for (++ns; --ns; ) {
1038
+ const llc = llt.s[lst];
1039
+ const lbtr = llt.n[lst];
1040
+ const mlc = mlt.s[mst];
1041
+ const mbtr = mlt.n[mst];
1042
+ const ofc = oct.s[ost];
1043
+ const obtr = oct.n[ost];
1044
+ cbt = (spos -= ofc) >> 3;
1045
+ const ofp = 1 << ofc;
1046
+ let off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
1047
+ cbt = (spos -= mlb[mlc]) >> 3;
1048
+ let ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
1049
+ cbt = (spos -= llb[llc]) >> 3;
1050
+ const ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
1051
+ cbt = (spos -= lbtr) >> 3;
1052
+ lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
1053
+ cbt = (spos -= mbtr) >> 3;
1054
+ mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
1055
+ cbt = (spos -= obtr) >> 3;
1056
+ ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
1057
+ if (off > 3) {
1058
+ st.o[2] = st.o[1];
1059
+ st.o[1] = st.o[0];
1060
+ st.o[0] = off -= 3;
1061
+ } else {
1062
+ const idx = off - (ll != 0);
1063
+ if (idx) {
1064
+ off = idx == 3 ? st.o[0] - 1 : st.o[idx];
1065
+ if (idx > 1) st.o[2] = st.o[1];
1066
+ st.o[1] = st.o[0];
1067
+ st.o[0] = off;
1068
+ } else off = st.o[0];
1069
+ }
1070
+ for (let i = 0; i < ll; ++i) {
1071
+ buf[oubt + i] = buf[spl + i];
1072
+ }
1073
+ oubt += ll, spl += ll;
1074
+ let stin = oubt - off;
1075
+ if (stin < 0) {
1076
+ let len = -stin;
1077
+ const bs = st.e + stin;
1078
+ if (len > ml) len = ml;
1079
+ for (let i = 0; i < len; ++i) {
1080
+ buf[oubt + i] = st.w[bs + i];
1081
+ }
1082
+ oubt += len, ml -= len, stin = 0;
1083
+ }
1084
+ for (let i = 0; i < ml; ++i) {
1085
+ buf[oubt + i] = buf[stin + i];
1086
+ }
1087
+ oubt += ml;
1088
+ }
1089
+ if (oubt != spl) {
1090
+ while (spl < buf.length) {
1091
+ buf[oubt++] = buf[spl++];
1092
+ }
1093
+ } else oubt = buf.length;
1094
+ if (out) st.y += oubt;
1095
+ else buf = slc(buf, 0, oubt);
1096
+ } else if (out) {
1097
+ st.y += lss;
1098
+ if (spl) {
1099
+ for (let i = 0; i < lss; ++i) {
1100
+ buf[i] = buf[spl + i];
1101
+ }
1102
+ }
1103
+ } else if (spl) buf = slc(buf, spl);
1104
+ st.b = ebt;
1105
+ return buf;
1106
+ }
1107
+ err(2);
1108
+ };
1109
+ var cct = (bufs, ol) => {
1110
+ if (bufs.length == 1) return bufs[0];
1111
+ const buf = new u8(ol);
1112
+ for (let i = 0, b = 0; i < bufs.length; ++i) {
1113
+ const chk = bufs[i];
1114
+ buf.set(chk, b);
1115
+ b += chk.length;
1116
+ }
1117
+ return buf;
1118
+ };
1119
+ function decompress(dat, buf, dic) {
1120
+ const bufs = [], nb = +!buf;
1121
+ let bt = 0, ol = 0;
1122
+ for (; dat.length; ) {
1123
+ const st = rzfh(dat, nb || buf);
1124
+ if (typeof st == "object") {
1125
+ if (st.d && !dic) err(6);
1126
+ if (dic) rdic(dic, st);
1127
+ if (nb) {
1128
+ buf = null;
1129
+ if (!dic && st.w.length == st.u) {
1130
+ bufs.push(buf = st.w);
1131
+ ol += st.u;
1132
+ }
1133
+ } else {
1134
+ bufs.push(buf);
1135
+ st.e = 0;
1136
+ }
1137
+ for (; !st.l; ) {
1138
+ const blk = rzb(dat, st, buf);
1139
+ if (!blk) err(5);
1140
+ if (buf) st.e = st.y;
1141
+ else {
1142
+ bufs.push(blk);
1143
+ ol += blk.length;
1144
+ cpw(st.w, 0, blk.length);
1145
+ st.w.set(blk, st.w.length - blk.length);
1146
+ }
1147
+ }
1148
+ bt = st.b + st.c * 4;
1149
+ } else bt = st;
1150
+ dat = dat.subarray(bt);
1151
+ }
1152
+ return cct(bufs, ol);
1153
+ }
564
1154
 
565
1155
  // src/format/header.ts
566
1156
  var HEADER_SIZE = 39;
@@ -674,7 +1264,7 @@ function parseRepo(data) {
674
1264
  validateFileType(header, 6 /* RepoInfo */);
675
1265
  let fbData = getDataAfterHeader(data);
676
1266
  if (header.compression === 1 /* Zstd */) {
677
- fbData = (0, import_fzstd.decompress)(fbData);
1267
+ fbData = decompress(fbData);
678
1268
  }
679
1269
  const bb = new import_flatbuffers.ByteBuffer(fbData);
680
1270
  const repo = Repo.getRootAsRepo(bb);
@@ -694,11 +1284,11 @@ function parseVirtualChunkContainers(repo) {
694
1284
  if (!configBytes || configBytes.length === 0) return result;
695
1285
  let config;
696
1286
  try {
697
- const ab = configBytes.buffer.slice(
1287
+ const ab2 = configBytes.buffer.slice(
698
1288
  configBytes.byteOffset,
699
1289
  configBytes.byteOffset + configBytes.byteLength
700
1290
  );
701
- config = flexbuffers.toObject(ab);
1291
+ config = flexbuffers.toObject(ab2);
702
1292
  } catch {
703
1293
  return result;
704
1294
  }
@@ -811,9 +1401,6 @@ function listTagsFromRepo(parsedRepo) {
811
1401
  return listRefs((i) => repo.tags(i), repo.tagsLength());
812
1402
  }
813
1403
 
814
- // src/reader/session.ts
815
- var import_fzstd2 = require("fzstd");
816
-
817
1404
  // src/cache/lru.ts
818
1405
  var LRUCache = class {
819
1406
  cache;
@@ -1786,6 +2373,60 @@ var Manifest = class _Manifest {
1786
2373
  };
1787
2374
 
1788
2375
  // src/format/flatbuffers/manifest-parser.ts
2376
+ var COMPRESSION_ALG_ZSTD_DICT = 1;
2377
+ var MAX_DECOMPRESSED_LOCATION_SIZE = 1024;
2378
+ function zstdFrameAllocSize(frame) {
2379
+ if (frame.length < 5 || frame[0] !== 40 || frame[1] !== 181 || frame[2] !== 47 || frame[3] !== 253) {
2380
+ return Infinity;
2381
+ }
2382
+ const flg = frame[4];
2383
+ const singleSegment = flg >> 5 & 1;
2384
+ const contentChecksum = flg >> 2 & 1;
2385
+ const dictIdFlag = flg & 3;
2386
+ const contentSizeFlag = flg >> 6;
2387
+ let pos = 5;
2388
+ let windowSize = 0;
2389
+ if (!singleSegment) {
2390
+ if (pos >= frame.length) return Infinity;
2391
+ const wd = frame[pos++];
2392
+ const base = 2 ** (10 + (wd >> 3));
2393
+ windowSize = base + base / 8 * (wd & 7);
2394
+ }
2395
+ pos += dictIdFlag === 3 ? 4 : dictIdFlag;
2396
+ const fcsBytes = contentSizeFlag ? 1 << contentSizeFlag : singleSegment;
2397
+ let contentSize = 0;
2398
+ if (fcsBytes) {
2399
+ if (pos + fcsBytes > frame.length) return Infinity;
2400
+ for (let i = 0; i < fcsBytes; i++) {
2401
+ contentSize += frame[pos + i] * 2 ** (8 * i);
2402
+ }
2403
+ if (contentSizeFlag === 1) contentSize += 256;
2404
+ if (singleSegment) windowSize = contentSize;
2405
+ }
2406
+ pos += fcsBytes;
2407
+ let blockOutput = 0;
2408
+ for (; ; ) {
2409
+ if (pos + 3 > frame.length) return Infinity;
2410
+ const blockHeader = frame[pos] | frame[pos + 1] << 8 | frame[pos + 2] << 16;
2411
+ pos += 3;
2412
+ const lastBlock = blockHeader & 1;
2413
+ const blockType = blockHeader >> 1 & 3;
2414
+ const blockSize = blockHeader >> 3;
2415
+ if (blockType === 3) return Infinity;
2416
+ if (blockType === 1) {
2417
+ blockOutput += blockSize;
2418
+ pos += 1;
2419
+ } else {
2420
+ blockOutput += blockType === 0 ? blockSize : Math.min(windowSize, 131072);
2421
+ pos += blockSize;
2422
+ }
2423
+ if (pos > frame.length) return Infinity;
2424
+ if (lastBlock) break;
2425
+ }
2426
+ if (contentChecksum) pos += 4;
2427
+ if (pos !== frame.length) return Infinity;
2428
+ return Math.max(contentSize || windowSize, blockOutput);
2429
+ }
1789
2430
  function parseManifest(data) {
1790
2431
  const bb = new import_flatbuffers3.ByteBuffer(data);
1791
2432
  const fbsManifest = Manifest.getRootAsManifest(bb);
@@ -1794,34 +2435,68 @@ function parseManifest(data) {
1794
2435
  const id = asObjectId12(
1795
2436
  idObj.bb.bytes().slice(idObj.bb_pos, idObj.bb_pos + 12)
1796
2437
  );
2438
+ const decodeLocation = makeLocationDecoder(fbsManifest);
1797
2439
  const arraysLength = fbsManifest.arraysLength();
1798
2440
  const arrays = [];
1799
2441
  for (let i = 0; i < arraysLength; i++) {
1800
2442
  const fbsArray = fbsManifest.arrays(i);
1801
2443
  if (fbsArray) {
1802
- arrays.push(parseArrayManifest(fbsArray));
2444
+ arrays.push(makeArrayManifest(fbsArray, decodeLocation));
1803
2445
  }
1804
2446
  }
1805
2447
  return { id, arrays };
1806
2448
  }
1807
- function parseArrayManifest(fbsArray) {
2449
+ function makeLocationDecoder(fbsManifest) {
2450
+ const dictionary = fbsManifest.compressionAlgorithm() === COMPRESSION_ALG_ZSTD_DICT ? fbsManifest.locationDictionaryArray() : null;
2451
+ const textDecoder = new TextDecoder("utf-8", { fatal: true });
2452
+ return (compressed) => {
2453
+ if (!dictionary) {
2454
+ throw new Error(
2455
+ "ChunkRef has a compressed_location but the manifest has no location dictionary"
2456
+ );
2457
+ }
2458
+ if (zstdFrameAllocSize(compressed) > MAX_DECOMPRESSED_LOCATION_SIZE) {
2459
+ throw new Error(
2460
+ `Compressed location declares a size over ${MAX_DECOMPRESSED_LOCATION_SIZE} bytes`
2461
+ );
2462
+ }
2463
+ const decompressed = decompress(compressed, void 0, dictionary);
2464
+ if (decompressed.length > MAX_DECOMPRESSED_LOCATION_SIZE) {
2465
+ throw new Error(
2466
+ `Decompressed location exceeds ${MAX_DECOMPRESSED_LOCATION_SIZE} bytes`
2467
+ );
2468
+ }
2469
+ return textDecoder.decode(decompressed);
2470
+ };
2471
+ }
2472
+ function makeArrayManifest(fbsArray, decodeLocation) {
1808
2473
  const nodeIdObj = fbsArray.nodeId();
1809
2474
  if (!nodeIdObj)
1810
2475
  throw new Error("ArrayManifest missing required node_id field");
1811
2476
  const nodeId = asObjectId8(
1812
2477
  nodeIdObj.bb.bytes().slice(nodeIdObj.bb_pos, nodeIdObj.bb_pos + 8)
1813
2478
  );
1814
- const refsLength = fbsArray.refsLength();
1815
- const refs = [];
1816
- for (let i = 0; i < refsLength; i++) {
1817
- const fbsRef = fbsArray.refs(i);
1818
- if (fbsRef) {
1819
- refs.push(parseChunkRef(fbsRef));
2479
+ const numRefs = fbsArray.refsLength();
2480
+ const probe = new ChunkRef();
2481
+ return {
2482
+ nodeId,
2483
+ numRefs,
2484
+ refIndex(i) {
2485
+ const fbsRef = fbsArray.refs(i, probe);
2486
+ if (!fbsRef) throw new Error(`Manifest ref ${i} out of range`);
2487
+ const indexLength = fbsRef.indexLength();
2488
+ const index = new Array(indexLength);
2489
+ for (let d = 0; d < indexLength; d++) index[d] = fbsRef.index(d);
2490
+ return index;
2491
+ },
2492
+ refAt(i) {
2493
+ const fbsRef = fbsArray.refs(i);
2494
+ if (!fbsRef) throw new Error(`Manifest ref ${i} out of range`);
2495
+ return parseChunkRef(fbsRef, decodeLocation);
1820
2496
  }
1821
- }
1822
- return { nodeId, refs };
2497
+ };
1823
2498
  }
1824
- function parseChunkRef(fbsRef) {
2499
+ function parseChunkRef(fbsRef, decodeLocation) {
1825
2500
  const indexLength = fbsRef.indexLength();
1826
2501
  const index = [];
1827
2502
  for (let i = 0; i < indexLength; i++) {
@@ -1835,24 +2510,42 @@ function parseChunkRef(fbsRef) {
1835
2510
  const chunkId = chunkIdObj ? asObjectId12(
1836
2511
  chunkIdObj.bb.bytes().slice(chunkIdObj.bb_pos, chunkIdObj.bb_pos + 12)
1837
2512
  ) : null;
1838
- const location = fbsRef.location();
1839
2513
  const checksumEtag = fbsRef.checksumEtag();
1840
2514
  const checksumLastModified = fbsRef.checksumLastModified();
1841
- return {
2515
+ const ref = {
1842
2516
  index,
1843
2517
  inline,
1844
2518
  offset,
1845
2519
  length,
1846
2520
  chunkId,
1847
- location,
2521
+ location: fbsRef.location(),
1848
2522
  checksumEtag,
1849
2523
  checksumLastModified
1850
2524
  };
2525
+ if (chunkId === null) {
2526
+ const compressed = fbsRef.compressedLocationArray();
2527
+ if (compressed) {
2528
+ let decoded = null;
2529
+ let resolved = false;
2530
+ Object.defineProperty(ref, "location", {
2531
+ configurable: true,
2532
+ enumerable: true,
2533
+ get() {
2534
+ if (!resolved) {
2535
+ decoded = decodeLocation(compressed);
2536
+ resolved = true;
2537
+ }
2538
+ return decoded;
2539
+ }
2540
+ });
2541
+ }
2542
+ }
2543
+ return ref;
1851
2544
  }
1852
2545
  function findChunkRef(manifest, nodeId, coords) {
1853
2546
  const arrayManifest = binarySearchArrayManifest(manifest.arrays, nodeId);
1854
2547
  if (!arrayManifest) return null;
1855
- return binarySearchChunkRef(arrayManifest.refs, coords);
2548
+ return binarySearchChunkRef(arrayManifest, coords);
1856
2549
  }
1857
2550
  function binarySearchArrayManifest(arrays, nodeId) {
1858
2551
  let low = 0;
@@ -1884,14 +2577,14 @@ function compareCoords(a, b) {
1884
2577
  }
1885
2578
  return a.length - b.length;
1886
2579
  }
1887
- function binarySearchChunkRef(refs, coords) {
2580
+ function binarySearchChunkRef(array, coords) {
1888
2581
  let low = 0;
1889
- let high = refs.length - 1;
2582
+ let high = array.numRefs - 1;
1890
2583
  while (low <= high) {
1891
2584
  const mid = Math.floor((low + high) / 2);
1892
- const cmp = compareCoords(refs[mid].index, coords);
2585
+ const cmp = compareCoords(array.refIndex(mid), coords);
1893
2586
  if (cmp === 0) {
1894
- return refs[mid];
2587
+ return array.refAt(mid);
1895
2588
  } else if (cmp < 0) {
1896
2589
  low = mid + 1;
1897
2590
  } else {
@@ -1901,9 +2594,6 @@ function binarySearchChunkRef(refs, coords) {
1901
2594
  return null;
1902
2595
  }
1903
2596
  function getChunkPayload(ref) {
1904
- if (ref.inline !== null) {
1905
- return { type: "inline", data: ref.inline };
1906
- }
1907
2597
  if (ref.chunkId !== null) {
1908
2598
  return {
1909
2599
  type: "native",
@@ -1922,7 +2612,10 @@ function getChunkPayload(ref) {
1922
2612
  checksumLastModified: ref.checksumLastModified
1923
2613
  };
1924
2614
  }
1925
- throw new Error("Invalid ChunkRef: no inline, chunkId, or location");
2615
+ if (ref.inline !== null) {
2616
+ return { type: "inline", data: ref.inline };
2617
+ }
2618
+ throw new Error("Invalid ChunkRef: no chunkId, location, or inline");
1926
2619
  }
1927
2620
 
1928
2621
  // src/format/flatbuffers/metadata.ts
@@ -2507,7 +3200,7 @@ var ReadSession = class _ReadSession {
2507
3200
  validateFileType(header, 1 /* Snapshot */);
2508
3201
  let flatbufferData = getDataAfterHeader(data);
2509
3202
  if (header.compression === 1 /* Zstd */) {
2510
- flatbufferData = (0, import_fzstd2.decompress)(flatbufferData);
3203
+ flatbufferData = decompress(flatbufferData);
2511
3204
  }
2512
3205
  return {
2513
3206
  snapshot: parseSnapshot(flatbufferData),
@@ -2545,7 +3238,7 @@ var ReadSession = class _ReadSession {
2545
3238
  validateFileType(header, 2 /* Manifest */);
2546
3239
  let flatbufferData = getDataAfterHeader(data);
2547
3240
  if (header.compression === 1 /* Zstd */) {
2548
- flatbufferData = (0, import_fzstd2.decompress)(flatbufferData);
3241
+ flatbufferData = decompress(flatbufferData);
2549
3242
  }
2550
3243
  return parseManifest(flatbufferData);
2551
3244
  }
@@ -2609,7 +3302,7 @@ var ReadSession = class _ReadSession {
2609
3302
  validateFileType(header, 4 /* TransactionLog */);
2610
3303
  let flatbufferData = getDataAfterHeader(data);
2611
3304
  if (header.compression === 1 /* Zstd */) {
2612
- flatbufferData = (0, import_fzstd2.decompress)(flatbufferData);
3305
+ flatbufferData = decompress(flatbufferData);
2613
3306
  }
2614
3307
  return parseTransactionLog(flatbufferData);
2615
3308
  }
@@ -3527,9 +4220,9 @@ var IcechunkStore = class _IcechunkStore {
3527
4220
  }
3528
4221
  });
3529
4222
  return chunk ?? void 0;
3530
- } catch (err) {
3531
- if (err instanceof NotFoundError) return void 0;
3532
- throw err;
4223
+ } catch (err2) {
4224
+ if (err2 instanceof NotFoundError) return void 0;
4225
+ throw err2;
3533
4226
  }
3534
4227
  }
3535
4228
  /**
@@ -3572,9 +4265,9 @@ var IcechunkStore = class _IcechunkStore {
3572
4265
  return data.slice(-range.suffixLength);
3573
4266
  }
3574
4267
  return data.slice(range.offset, range.offset + range.length);
3575
- } catch (err) {
3576
- if (err instanceof NotFoundError) return void 0;
3577
- throw err;
4268
+ } catch (err2) {
4269
+ if (err2 instanceof NotFoundError) return void 0;
4270
+ throw err2;
3578
4271
  }
3579
4272
  }
3580
4273
  /** Prepend basePath to a parsed path. */