icechunk-js 0.4.0 → 0.5.0

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,17 +2435,41 @@ 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(parseArrayManifest(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 parseArrayManifest(fbsArray, decodeLocation) {
1808
2473
  const nodeIdObj = fbsArray.nodeId();
1809
2474
  if (!nodeIdObj)
1810
2475
  throw new Error("ArrayManifest missing required node_id field");
@@ -1816,12 +2481,12 @@ function parseArrayManifest(fbsArray) {
1816
2481
  for (let i = 0; i < refsLength; i++) {
1817
2482
  const fbsRef = fbsArray.refs(i);
1818
2483
  if (fbsRef) {
1819
- refs.push(parseChunkRef(fbsRef));
2484
+ refs.push(parseChunkRef(fbsRef, decodeLocation));
1820
2485
  }
1821
2486
  }
1822
2487
  return { nodeId, refs };
1823
2488
  }
1824
- function parseChunkRef(fbsRef) {
2489
+ function parseChunkRef(fbsRef, decodeLocation) {
1825
2490
  const indexLength = fbsRef.indexLength();
1826
2491
  const index = [];
1827
2492
  for (let i = 0; i < indexLength; i++) {
@@ -1835,19 +2500,37 @@ function parseChunkRef(fbsRef) {
1835
2500
  const chunkId = chunkIdObj ? asObjectId12(
1836
2501
  chunkIdObj.bb.bytes().slice(chunkIdObj.bb_pos, chunkIdObj.bb_pos + 12)
1837
2502
  ) : null;
1838
- const location = fbsRef.location();
1839
2503
  const checksumEtag = fbsRef.checksumEtag();
1840
2504
  const checksumLastModified = fbsRef.checksumLastModified();
1841
- return {
2505
+ const ref = {
1842
2506
  index,
1843
2507
  inline,
1844
2508
  offset,
1845
2509
  length,
1846
2510
  chunkId,
1847
- location,
2511
+ location: fbsRef.location(),
1848
2512
  checksumEtag,
1849
2513
  checksumLastModified
1850
2514
  };
2515
+ if (chunkId === null) {
2516
+ const compressed = fbsRef.compressedLocationArray();
2517
+ if (compressed) {
2518
+ let decoded = null;
2519
+ let resolved = false;
2520
+ Object.defineProperty(ref, "location", {
2521
+ configurable: true,
2522
+ enumerable: true,
2523
+ get() {
2524
+ if (!resolved) {
2525
+ decoded = decodeLocation(compressed);
2526
+ resolved = true;
2527
+ }
2528
+ return decoded;
2529
+ }
2530
+ });
2531
+ }
2532
+ }
2533
+ return ref;
1851
2534
  }
1852
2535
  function findChunkRef(manifest, nodeId, coords) {
1853
2536
  const arrayManifest = binarySearchArrayManifest(manifest.arrays, nodeId);
@@ -1901,9 +2584,6 @@ function binarySearchChunkRef(refs, coords) {
1901
2584
  return null;
1902
2585
  }
1903
2586
  function getChunkPayload(ref) {
1904
- if (ref.inline !== null) {
1905
- return { type: "inline", data: ref.inline };
1906
- }
1907
2587
  if (ref.chunkId !== null) {
1908
2588
  return {
1909
2589
  type: "native",
@@ -1922,7 +2602,10 @@ function getChunkPayload(ref) {
1922
2602
  checksumLastModified: ref.checksumLastModified
1923
2603
  };
1924
2604
  }
1925
- throw new Error("Invalid ChunkRef: no inline, chunkId, or location");
2605
+ if (ref.inline !== null) {
2606
+ return { type: "inline", data: ref.inline };
2607
+ }
2608
+ throw new Error("Invalid ChunkRef: no chunkId, location, or inline");
1926
2609
  }
1927
2610
 
1928
2611
  // src/format/flatbuffers/metadata.ts
@@ -2507,7 +3190,7 @@ var ReadSession = class _ReadSession {
2507
3190
  validateFileType(header, 1 /* Snapshot */);
2508
3191
  let flatbufferData = getDataAfterHeader(data);
2509
3192
  if (header.compression === 1 /* Zstd */) {
2510
- flatbufferData = (0, import_fzstd2.decompress)(flatbufferData);
3193
+ flatbufferData = decompress(flatbufferData);
2511
3194
  }
2512
3195
  return {
2513
3196
  snapshot: parseSnapshot(flatbufferData),
@@ -2545,7 +3228,7 @@ var ReadSession = class _ReadSession {
2545
3228
  validateFileType(header, 2 /* Manifest */);
2546
3229
  let flatbufferData = getDataAfterHeader(data);
2547
3230
  if (header.compression === 1 /* Zstd */) {
2548
- flatbufferData = (0, import_fzstd2.decompress)(flatbufferData);
3231
+ flatbufferData = decompress(flatbufferData);
2549
3232
  }
2550
3233
  return parseManifest(flatbufferData);
2551
3234
  }
@@ -2609,7 +3292,7 @@ var ReadSession = class _ReadSession {
2609
3292
  validateFileType(header, 4 /* TransactionLog */);
2610
3293
  let flatbufferData = getDataAfterHeader(data);
2611
3294
  if (header.compression === 1 /* Zstd */) {
2612
- flatbufferData = (0, import_fzstd2.decompress)(flatbufferData);
3295
+ flatbufferData = decompress(flatbufferData);
2613
3296
  }
2614
3297
  return parseTransactionLog(flatbufferData);
2615
3298
  }
@@ -3527,9 +4210,9 @@ var IcechunkStore = class _IcechunkStore {
3527
4210
  }
3528
4211
  });
3529
4212
  return chunk ?? void 0;
3530
- } catch (err) {
3531
- if (err instanceof NotFoundError) return void 0;
3532
- throw err;
4213
+ } catch (err2) {
4214
+ if (err2 instanceof NotFoundError) return void 0;
4215
+ throw err2;
3533
4216
  }
3534
4217
  }
3535
4218
  /**
@@ -3572,9 +4255,9 @@ var IcechunkStore = class _IcechunkStore {
3572
4255
  return data.slice(-range.suffixLength);
3573
4256
  }
3574
4257
  return data.slice(range.offset, range.offset + range.length);
3575
- } catch (err) {
3576
- if (err instanceof NotFoundError) return void 0;
3577
- throw err;
4258
+ } catch (err2) {
4259
+ if (err2 instanceof NotFoundError) return void 0;
4260
+ throw err2;
3578
4261
  }
3579
4262
  }
3580
4263
  /** Prepend basePath to a parsed path. */