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.js CHANGED
@@ -299,6 +299,17 @@ var SnapshotInfo = class _SnapshotInfo {
299
299
  const offset = this.bb.__offset(this.bb_pos, 12);
300
300
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
301
301
  }
302
+ prunedAncestorTxLogs(index, obj) {
303
+ const offset = this.bb.__offset(this.bb_pos, 14);
304
+ return offset ? (obj || new ObjectId12()).__init(
305
+ this.bb.__vector(this.bb_pos + offset) + index * 12,
306
+ this.bb
307
+ ) : null;
308
+ }
309
+ prunedAncestorTxLogsLength() {
310
+ const offset = this.bb.__offset(this.bb_pos, 14);
311
+ return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
312
+ }
302
313
  };
303
314
 
304
315
  // src/format/flatbuffers/generated/update.ts
@@ -506,8 +517,587 @@ var Repo = class _Repo {
506
517
  }
507
518
  };
508
519
 
509
- // src/format/flatbuffers/repo-parser.ts
510
- import { decompress } from "fzstd";
520
+ // src/vendor/fzstd/index.ts
521
+ var ab = ArrayBuffer;
522
+ var u8 = Uint8Array;
523
+ var u16 = Uint16Array;
524
+ var i16 = Int16Array;
525
+ var i32 = Int32Array;
526
+ var slc = (v, s, e) => {
527
+ if (u8.prototype.slice) return u8.prototype.slice.call(v, s, e);
528
+ if (s == null || s < 0) s = 0;
529
+ if (e == null || e > v.length) e = v.length;
530
+ const n = new u8(e - s);
531
+ n.set(v.subarray(s, e));
532
+ return n;
533
+ };
534
+ var fill = (v, n, s, e) => {
535
+ if (u8.prototype.fill) return u8.prototype.fill.call(v, n, s, e);
536
+ if (s == null || s < 0) s = 0;
537
+ if (e == null || e > v.length) e = v.length;
538
+ for (; s < e; ++s) v[s] = n;
539
+ return v;
540
+ };
541
+ var cpw = (v, t, s, e) => {
542
+ if (u8.prototype.copyWithin) return u8.prototype.copyWithin.call(v, t, s, e);
543
+ if (s == null || s < 0) s = 0;
544
+ if (e == null || e > v.length) e = v.length;
545
+ while (s < e) {
546
+ v[t++] = v[s++];
547
+ }
548
+ };
549
+ var ec = [
550
+ "invalid zstd data",
551
+ "window size too large (>2046MB)",
552
+ "invalid block type",
553
+ "FSE accuracy too high",
554
+ "match distance too far back",
555
+ "unexpected EOF",
556
+ "wrong dictionary"
557
+ ];
558
+ var err = (ind, msg, nt) => {
559
+ const e = new Error(msg || ec[ind]);
560
+ e.code = ind;
561
+ if (Error.captureStackTrace) Error.captureStackTrace(e, err);
562
+ if (!nt) throw e;
563
+ return e;
564
+ };
565
+ var rb = (d, b, n) => {
566
+ let i = 0, o = 0;
567
+ for (; i < n; ++i) o |= d[b++] << (i << 3);
568
+ return o;
569
+ };
570
+ var b4 = (d, b) => (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
571
+ var rdic = (dic, st) => {
572
+ if (b4(dic, 0) == 3962610743) {
573
+ if (st.d && st.d !== b4(dic, 4)) err(6);
574
+ let bt = 8;
575
+ [bt, st.h] = rhu(dic, bt);
576
+ let mlt, olt, llt;
577
+ [bt, olt] = rfse(dic, bt, 8);
578
+ [bt, mlt] = rfse(dic, bt, 9);
579
+ [bt, llt] = rfse(dic, bt, 9);
580
+ st.t = [mlt, olt, llt];
581
+ st.o = new i32([b4(dic, bt), b4(dic, bt + 4), b4(dic, bt + 8)]);
582
+ dic = dic.subarray(bt + 12);
583
+ }
584
+ const wl = Math.max(dic.length, st.u ? Math.min(st.e, dic.length + st.u) : st.e);
585
+ st.w = new u8(wl);
586
+ st.w.set(dic, wl - dic.length);
587
+ st.e = wl;
588
+ };
589
+ var rzfh = (dat, w) => {
590
+ const n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
591
+ if (n3 == 3126568 && dat[3] == 253) {
592
+ const flg = dat[4];
593
+ const ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
594
+ if (flg & 8) err(0);
595
+ let bt = 6 - ss;
596
+ const db = df == 3 ? 4 : df;
597
+ const di = rb(dat, bt, db);
598
+ bt += db;
599
+ const fsb = fcf ? 1 << fcf : ss;
600
+ const fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
601
+ let ws = fss;
602
+ if (!ss) {
603
+ const wb = 1 << 10 + (dat[5] >> 3);
604
+ ws = wb + (wb >> 3) * (dat[5] & 7);
605
+ }
606
+ if (ws > 2145386496) err(1);
607
+ const buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
608
+ buf[0] = 1, buf[4] = 4, buf[8] = 8;
609
+ return {
610
+ b: bt + fsb,
611
+ y: 0,
612
+ l: 0,
613
+ d: di,
614
+ w: w && w != 1 ? w : buf.subarray(12),
615
+ e: ws,
616
+ o: new i32(buf.buffer, 0, 3),
617
+ u: fss,
618
+ c: cc,
619
+ m: Math.min(131072, ws)
620
+ };
621
+ } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
622
+ return b4(dat, 4) + 8;
623
+ }
624
+ err(0);
625
+ };
626
+ var msb = (val) => {
627
+ let bits = 0;
628
+ for (; 1 << bits <= val; ++bits) ;
629
+ return bits - 1;
630
+ };
631
+ var rfse = (dat, bt, mal) => {
632
+ let tpos = (bt << 3) + 4;
633
+ const al = (dat[bt] & 15) + 5;
634
+ if (al > mal) err(3);
635
+ const sz = 1 << al;
636
+ let probs = sz, sym = -1, re = -1, i = -1, ht = sz;
637
+ const buf = new ab(512 + (sz << 2));
638
+ const freq = new i16(buf, 0, 256);
639
+ const dstate = new u16(buf, 0, 256);
640
+ const nstate = new u16(buf, 512, sz);
641
+ const bb1 = 512 + (sz << 1);
642
+ const syms = new u8(buf, bb1, sz);
643
+ const nbits = new u8(buf, bb1 + sz);
644
+ while (sym < 255 && probs > 0) {
645
+ const bits = msb(probs + 1);
646
+ const cbt = tpos >> 3;
647
+ const msk = (1 << bits + 1) - 1;
648
+ let val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
649
+ const msk1fb = (1 << bits) - 1;
650
+ const msv = msk - probs - 1;
651
+ const sval = val & msk1fb;
652
+ if (sval < msv) tpos += bits, val = sval;
653
+ else {
654
+ tpos += bits + 1;
655
+ if (val > msk1fb) val -= msv;
656
+ }
657
+ freq[++sym] = --val;
658
+ if (val == -1) {
659
+ probs += val;
660
+ syms[--ht] = sym;
661
+ } else probs -= val;
662
+ if (!val) {
663
+ do {
664
+ const rbt = tpos >> 3;
665
+ re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
666
+ tpos += 2;
667
+ sym += re;
668
+ } while (re == 3);
669
+ }
670
+ }
671
+ if (sym > 255 || probs) err(0);
672
+ let sympos = 0;
673
+ const sstep = (sz >> 1) + (sz >> 3) + 3;
674
+ const smask = sz - 1;
675
+ for (let s = 0; s <= sym; ++s) {
676
+ const sf = freq[s];
677
+ if (sf < 1) {
678
+ dstate[s] = -sf;
679
+ continue;
680
+ }
681
+ for (i = 0; i < sf; ++i) {
682
+ syms[sympos] = s;
683
+ do {
684
+ sympos = sympos + sstep & smask;
685
+ } while (sympos >= ht);
686
+ }
687
+ }
688
+ if (sympos) err(0);
689
+ for (i = 0; i < sz; ++i) {
690
+ const ns = dstate[syms[i]]++;
691
+ const nb = nbits[i] = al - msb(ns);
692
+ nstate[i] = (ns << nb) - sz;
693
+ }
694
+ return [tpos + 7 >> 3, {
695
+ b: al,
696
+ s: syms,
697
+ n: nbits,
698
+ t: nstate
699
+ }];
700
+ };
701
+ var rhu = (dat, bt) => {
702
+ let i = 0, wc = -1;
703
+ const buf = new u8(292), hb = dat[bt];
704
+ const hw = buf.subarray(0, 256);
705
+ const rc = buf.subarray(256, 268);
706
+ const ri = new u16(buf.buffer, 268);
707
+ if (hb < 128) {
708
+ const [ebt, fdt] = rfse(dat, bt + 1, 6);
709
+ bt += hb;
710
+ const epos = ebt << 3;
711
+ const lb = dat[bt];
712
+ if (!lb) err(0);
713
+ let st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
714
+ let fpos = (++bt << 3) - 8 + msb(lb);
715
+ for (; ; ) {
716
+ fpos -= btr1;
717
+ if (fpos < epos) break;
718
+ let cbt = fpos >> 3;
719
+ st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
720
+ hw[++wc] = fdt.s[st1];
721
+ fpos -= btr2;
722
+ if (fpos < epos) break;
723
+ cbt = fpos >> 3;
724
+ st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
725
+ hw[++wc] = fdt.s[st2];
726
+ btr1 = fdt.n[st1];
727
+ st1 = fdt.t[st1];
728
+ btr2 = fdt.n[st2];
729
+ st2 = fdt.t[st2];
730
+ }
731
+ if (++wc > 255) err(0);
732
+ } else {
733
+ wc = hb - 127;
734
+ for (; i < wc; i += 2) {
735
+ const byte = dat[++bt];
736
+ hw[i] = byte >> 4;
737
+ hw[i + 1] = byte & 15;
738
+ }
739
+ ++bt;
740
+ }
741
+ let wes = 0;
742
+ for (i = 0; i < wc; ++i) {
743
+ const wt = hw[i];
744
+ if (wt > 11) err(0);
745
+ wes += wt && 1 << wt - 1;
746
+ }
747
+ const mb = msb(wes) + 1;
748
+ const ts = 1 << mb;
749
+ const rem = ts - wes;
750
+ if (rem & rem - 1) err(0);
751
+ hw[wc++] = msb(rem) + 1;
752
+ for (i = 0; i < wc; ++i) {
753
+ const wt = hw[i];
754
+ ++rc[hw[i] = wt && mb + 1 - wt];
755
+ }
756
+ const hbuf = new u8(ts << 1);
757
+ const syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
758
+ ri[mb] = 0;
759
+ for (i = mb; i > 0; --i) {
760
+ const pv = ri[i];
761
+ fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
762
+ }
763
+ if (ri[0] != ts) err(0);
764
+ for (i = 0; i < wc; ++i) {
765
+ const bits = hw[i];
766
+ if (bits) {
767
+ const code = ri[bits];
768
+ fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
769
+ }
770
+ }
771
+ return [bt, {
772
+ n: nb,
773
+ b: mb,
774
+ s: syms
775
+ }];
776
+ };
777
+ var dllt = rfse(/* @__PURE__ */ new u8([
778
+ 81,
779
+ 16,
780
+ 99,
781
+ 140,
782
+ 49,
783
+ 198,
784
+ 24,
785
+ 99,
786
+ 12,
787
+ 33,
788
+ 196,
789
+ 24,
790
+ 99,
791
+ 102,
792
+ 102,
793
+ 134,
794
+ 70,
795
+ 146,
796
+ 4
797
+ ]), 0, 6)[1];
798
+ var dmlt = rfse(/* @__PURE__ */ new u8([
799
+ 33,
800
+ 20,
801
+ 196,
802
+ 24,
803
+ 99,
804
+ 140,
805
+ 33,
806
+ 132,
807
+ 16,
808
+ 66,
809
+ 8,
810
+ 33,
811
+ 132,
812
+ 16,
813
+ 66,
814
+ 8,
815
+ 33,
816
+ 68,
817
+ 68,
818
+ 68,
819
+ 68,
820
+ 68,
821
+ 68,
822
+ 68,
823
+ 68,
824
+ 36,
825
+ 9
826
+ ]), 0, 6)[1];
827
+ var doct = rfse(/* @__PURE__ */ new u8([
828
+ 32,
829
+ 132,
830
+ 16,
831
+ 66,
832
+ 102,
833
+ 70,
834
+ 68,
835
+ 68,
836
+ 68,
837
+ 68,
838
+ 36,
839
+ 73,
840
+ 2
841
+ ]), 0, 5)[1];
842
+ var b2bl = (b, s) => {
843
+ const len = b.length, bl = new i32(len);
844
+ for (let i = 0; i < len; ++i) {
845
+ bl[i] = s;
846
+ s += 1 << b[i];
847
+ }
848
+ return bl;
849
+ };
850
+ var llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
851
+ 0,
852
+ 0,
853
+ 0,
854
+ 0,
855
+ 16843009,
856
+ 50528770,
857
+ 134678020,
858
+ 202050057,
859
+ 269422093
860
+ ])).buffer, 0, 36);
861
+ var llbl = /* @__PURE__ */ b2bl(llb, 0);
862
+ var mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
863
+ 0,
864
+ 0,
865
+ 0,
866
+ 0,
867
+ 0,
868
+ 0,
869
+ 0,
870
+ 0,
871
+ 16843009,
872
+ 50528770,
873
+ 117769220,
874
+ 185207048,
875
+ 252579084,
876
+ 16
877
+ ])).buffer, 0, 53);
878
+ var mlbl = /* @__PURE__ */ b2bl(mlb, 3);
879
+ var dhu = (dat, out, hu) => {
880
+ const len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
881
+ if (!lb) err(0);
882
+ let st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
883
+ for (; pos > eb && i < ss; ) {
884
+ const cbt = pos >> 3;
885
+ const val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
886
+ st = (st << btr | val) & msk;
887
+ out[++i] = hu.s[st];
888
+ pos -= btr = hu.n[st];
889
+ }
890
+ if (pos != eb || i + 1 != ss) err(0);
891
+ };
892
+ var dhu4 = (dat, out, hu) => {
893
+ let bt = 6;
894
+ const ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
895
+ dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
896
+ dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
897
+ dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
898
+ dhu(dat.subarray(bt), out.subarray(sz3), hu);
899
+ };
900
+ var rzb = (dat, st, out) => {
901
+ let bt = st.b;
902
+ const b0 = dat[bt], btype = b0 >> 1 & 3;
903
+ st.l = b0 & 1;
904
+ const sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
905
+ const ebt = (bt += 3) + sz;
906
+ if (btype == 1) {
907
+ if (bt >= dat.length) return;
908
+ st.b = bt + 1;
909
+ if (out) {
910
+ fill(out, dat[bt], st.y, st.y += sz);
911
+ return out;
912
+ }
913
+ return fill(new u8(sz), dat[bt]);
914
+ }
915
+ if (ebt > dat.length) return;
916
+ if (btype == 0) {
917
+ st.b = ebt;
918
+ if (out) {
919
+ out.set(dat.subarray(bt, ebt), st.y);
920
+ st.y += sz;
921
+ return out;
922
+ }
923
+ return slc(dat, bt, ebt);
924
+ }
925
+ if (btype == 2) {
926
+ const b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
927
+ let lss = b3 >> 4, lcs = 0, s4 = 0;
928
+ if (lbt < 2) {
929
+ if (sf & 1) lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
930
+ else lss = b3 >> 3;
931
+ } else {
932
+ s4 = sf;
933
+ if (sf < 2) lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
934
+ else if (sf == 2) lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
935
+ else lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
936
+ }
937
+ ++bt;
938
+ let buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
939
+ let spl = buf.length - lss;
940
+ if (lbt == 0) buf.set(dat.subarray(bt, bt += lss), spl);
941
+ else if (lbt == 1) fill(buf, dat[bt++], spl);
942
+ else {
943
+ let hu = st.h;
944
+ if (lbt == 2) {
945
+ const hud = rhu(dat, bt);
946
+ lcs += bt - (bt = hud[0]);
947
+ st.h = hu = hud[1];
948
+ } else if (!hu) err(0);
949
+ (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
950
+ }
951
+ let ns = dat[bt++];
952
+ if (ns) {
953
+ if (ns == 255) ns = (dat[bt++] | dat[bt++] << 8) + 32512;
954
+ else if (ns > 127) ns = ns - 128 << 8 | dat[bt++];
955
+ const scm = dat[bt++];
956
+ if (scm & 3) err(0);
957
+ const dts = [dmlt, doct, dllt];
958
+ for (let i = 2; i > -1; --i) {
959
+ const md = scm >> (i << 1) + 2 & 3;
960
+ if (md == 1) {
961
+ const rbuf = new u8([0, 0, dat[bt++]]);
962
+ dts[i] = {
963
+ s: rbuf.subarray(2, 3),
964
+ n: rbuf.subarray(0, 1),
965
+ t: new u16(rbuf.buffer, 0, 1),
966
+ b: 0
967
+ };
968
+ } else if (md == 2) {
969
+ [bt, dts[i]] = rfse(dat, bt, 9 - (i & 1));
970
+ } else if (md == 3) {
971
+ if (!st.t) err(0);
972
+ dts[i] = st.t[i];
973
+ }
974
+ }
975
+ const [mlt, oct, llt] = st.t = dts;
976
+ const lb = dat[ebt - 1];
977
+ if (!lb) err(0);
978
+ let spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
979
+ let lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
980
+ cbt = (spos -= oct.b) >> 3;
981
+ let ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
982
+ cbt = (spos -= mlt.b) >> 3;
983
+ let mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
984
+ for (++ns; --ns; ) {
985
+ const llc = llt.s[lst];
986
+ const lbtr = llt.n[lst];
987
+ const mlc = mlt.s[mst];
988
+ const mbtr = mlt.n[mst];
989
+ const ofc = oct.s[ost];
990
+ const obtr = oct.n[ost];
991
+ cbt = (spos -= ofc) >> 3;
992
+ const ofp = 1 << ofc;
993
+ let off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
994
+ cbt = (spos -= mlb[mlc]) >> 3;
995
+ let ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
996
+ cbt = (spos -= llb[llc]) >> 3;
997
+ const ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
998
+ cbt = (spos -= lbtr) >> 3;
999
+ lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
1000
+ cbt = (spos -= mbtr) >> 3;
1001
+ mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
1002
+ cbt = (spos -= obtr) >> 3;
1003
+ ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
1004
+ if (off > 3) {
1005
+ st.o[2] = st.o[1];
1006
+ st.o[1] = st.o[0];
1007
+ st.o[0] = off -= 3;
1008
+ } else {
1009
+ const idx = off - (ll != 0);
1010
+ if (idx) {
1011
+ off = idx == 3 ? st.o[0] - 1 : st.o[idx];
1012
+ if (idx > 1) st.o[2] = st.o[1];
1013
+ st.o[1] = st.o[0];
1014
+ st.o[0] = off;
1015
+ } else off = st.o[0];
1016
+ }
1017
+ for (let i = 0; i < ll; ++i) {
1018
+ buf[oubt + i] = buf[spl + i];
1019
+ }
1020
+ oubt += ll, spl += ll;
1021
+ let stin = oubt - off;
1022
+ if (stin < 0) {
1023
+ let len = -stin;
1024
+ const bs = st.e + stin;
1025
+ if (len > ml) len = ml;
1026
+ for (let i = 0; i < len; ++i) {
1027
+ buf[oubt + i] = st.w[bs + i];
1028
+ }
1029
+ oubt += len, ml -= len, stin = 0;
1030
+ }
1031
+ for (let i = 0; i < ml; ++i) {
1032
+ buf[oubt + i] = buf[stin + i];
1033
+ }
1034
+ oubt += ml;
1035
+ }
1036
+ if (oubt != spl) {
1037
+ while (spl < buf.length) {
1038
+ buf[oubt++] = buf[spl++];
1039
+ }
1040
+ } else oubt = buf.length;
1041
+ if (out) st.y += oubt;
1042
+ else buf = slc(buf, 0, oubt);
1043
+ } else if (out) {
1044
+ st.y += lss;
1045
+ if (spl) {
1046
+ for (let i = 0; i < lss; ++i) {
1047
+ buf[i] = buf[spl + i];
1048
+ }
1049
+ }
1050
+ } else if (spl) buf = slc(buf, spl);
1051
+ st.b = ebt;
1052
+ return buf;
1053
+ }
1054
+ err(2);
1055
+ };
1056
+ var cct = (bufs, ol) => {
1057
+ if (bufs.length == 1) return bufs[0];
1058
+ const buf = new u8(ol);
1059
+ for (let i = 0, b = 0; i < bufs.length; ++i) {
1060
+ const chk = bufs[i];
1061
+ buf.set(chk, b);
1062
+ b += chk.length;
1063
+ }
1064
+ return buf;
1065
+ };
1066
+ function decompress(dat, buf, dic) {
1067
+ const bufs = [], nb = +!buf;
1068
+ let bt = 0, ol = 0;
1069
+ for (; dat.length; ) {
1070
+ const st = rzfh(dat, nb || buf);
1071
+ if (typeof st == "object") {
1072
+ if (st.d && !dic) err(6);
1073
+ if (dic) rdic(dic, st);
1074
+ if (nb) {
1075
+ buf = null;
1076
+ if (!dic && st.w.length == st.u) {
1077
+ bufs.push(buf = st.w);
1078
+ ol += st.u;
1079
+ }
1080
+ } else {
1081
+ bufs.push(buf);
1082
+ st.e = 0;
1083
+ }
1084
+ for (; !st.l; ) {
1085
+ const blk = rzb(dat, st, buf);
1086
+ if (!blk) err(5);
1087
+ if (buf) st.e = st.y;
1088
+ else {
1089
+ bufs.push(blk);
1090
+ ol += blk.length;
1091
+ cpw(st.w, 0, blk.length);
1092
+ st.w.set(blk, st.w.length - blk.length);
1093
+ }
1094
+ }
1095
+ bt = st.b + st.c * 4;
1096
+ } else bt = st;
1097
+ dat = dat.subarray(bt);
1098
+ }
1099
+ return cct(bufs, ol);
1100
+ }
511
1101
 
512
1102
  // src/format/header.ts
513
1103
  var HEADER_SIZE = 39;
@@ -641,11 +1231,11 @@ function parseVirtualChunkContainers(repo) {
641
1231
  if (!configBytes || configBytes.length === 0) return result;
642
1232
  let config;
643
1233
  try {
644
- const ab = configBytes.buffer.slice(
1234
+ const ab2 = configBytes.buffer.slice(
645
1235
  configBytes.byteOffset,
646
1236
  configBytes.byteOffset + configBytes.byteLength
647
1237
  );
648
- config = flexbuffers.toObject(ab);
1238
+ config = flexbuffers.toObject(ab2);
649
1239
  } catch {
650
1240
  return result;
651
1241
  }
@@ -758,9 +1348,6 @@ function listTagsFromRepo(parsedRepo) {
758
1348
  return listRefs((i) => repo.tags(i), repo.tagsLength());
759
1349
  }
760
1350
 
761
- // src/reader/session.ts
762
- import { decompress as decompress2 } from "fzstd";
763
-
764
1351
  // src/cache/lru.ts
765
1352
  var LRUCache = class {
766
1353
  cache;
@@ -1733,6 +2320,60 @@ var Manifest = class _Manifest {
1733
2320
  };
1734
2321
 
1735
2322
  // src/format/flatbuffers/manifest-parser.ts
2323
+ var COMPRESSION_ALG_ZSTD_DICT = 1;
2324
+ var MAX_DECOMPRESSED_LOCATION_SIZE = 1024;
2325
+ function zstdFrameAllocSize(frame) {
2326
+ if (frame.length < 5 || frame[0] !== 40 || frame[1] !== 181 || frame[2] !== 47 || frame[3] !== 253) {
2327
+ return Infinity;
2328
+ }
2329
+ const flg = frame[4];
2330
+ const singleSegment = flg >> 5 & 1;
2331
+ const contentChecksum = flg >> 2 & 1;
2332
+ const dictIdFlag = flg & 3;
2333
+ const contentSizeFlag = flg >> 6;
2334
+ let pos = 5;
2335
+ let windowSize = 0;
2336
+ if (!singleSegment) {
2337
+ if (pos >= frame.length) return Infinity;
2338
+ const wd = frame[pos++];
2339
+ const base = 2 ** (10 + (wd >> 3));
2340
+ windowSize = base + base / 8 * (wd & 7);
2341
+ }
2342
+ pos += dictIdFlag === 3 ? 4 : dictIdFlag;
2343
+ const fcsBytes = contentSizeFlag ? 1 << contentSizeFlag : singleSegment;
2344
+ let contentSize = 0;
2345
+ if (fcsBytes) {
2346
+ if (pos + fcsBytes > frame.length) return Infinity;
2347
+ for (let i = 0; i < fcsBytes; i++) {
2348
+ contentSize += frame[pos + i] * 2 ** (8 * i);
2349
+ }
2350
+ if (contentSizeFlag === 1) contentSize += 256;
2351
+ if (singleSegment) windowSize = contentSize;
2352
+ }
2353
+ pos += fcsBytes;
2354
+ let blockOutput = 0;
2355
+ for (; ; ) {
2356
+ if (pos + 3 > frame.length) return Infinity;
2357
+ const blockHeader = frame[pos] | frame[pos + 1] << 8 | frame[pos + 2] << 16;
2358
+ pos += 3;
2359
+ const lastBlock = blockHeader & 1;
2360
+ const blockType = blockHeader >> 1 & 3;
2361
+ const blockSize = blockHeader >> 3;
2362
+ if (blockType === 3) return Infinity;
2363
+ if (blockType === 1) {
2364
+ blockOutput += blockSize;
2365
+ pos += 1;
2366
+ } else {
2367
+ blockOutput += blockType === 0 ? blockSize : Math.min(windowSize, 131072);
2368
+ pos += blockSize;
2369
+ }
2370
+ if (pos > frame.length) return Infinity;
2371
+ if (lastBlock) break;
2372
+ }
2373
+ if (contentChecksum) pos += 4;
2374
+ if (pos !== frame.length) return Infinity;
2375
+ return Math.max(contentSize || windowSize, blockOutput);
2376
+ }
1736
2377
  function parseManifest(data) {
1737
2378
  const bb = new ByteBuffer3(data);
1738
2379
  const fbsManifest = Manifest.getRootAsManifest(bb);
@@ -1741,17 +2382,41 @@ function parseManifest(data) {
1741
2382
  const id = asObjectId12(
1742
2383
  idObj.bb.bytes().slice(idObj.bb_pos, idObj.bb_pos + 12)
1743
2384
  );
2385
+ const decodeLocation = makeLocationDecoder(fbsManifest);
1744
2386
  const arraysLength = fbsManifest.arraysLength();
1745
2387
  const arrays = [];
1746
2388
  for (let i = 0; i < arraysLength; i++) {
1747
2389
  const fbsArray = fbsManifest.arrays(i);
1748
2390
  if (fbsArray) {
1749
- arrays.push(parseArrayManifest(fbsArray));
2391
+ arrays.push(parseArrayManifest(fbsArray, decodeLocation));
1750
2392
  }
1751
2393
  }
1752
2394
  return { id, arrays };
1753
2395
  }
1754
- function parseArrayManifest(fbsArray) {
2396
+ function makeLocationDecoder(fbsManifest) {
2397
+ const dictionary = fbsManifest.compressionAlgorithm() === COMPRESSION_ALG_ZSTD_DICT ? fbsManifest.locationDictionaryArray() : null;
2398
+ const textDecoder = new TextDecoder("utf-8", { fatal: true });
2399
+ return (compressed) => {
2400
+ if (!dictionary) {
2401
+ throw new Error(
2402
+ "ChunkRef has a compressed_location but the manifest has no location dictionary"
2403
+ );
2404
+ }
2405
+ if (zstdFrameAllocSize(compressed) > MAX_DECOMPRESSED_LOCATION_SIZE) {
2406
+ throw new Error(
2407
+ `Compressed location declares a size over ${MAX_DECOMPRESSED_LOCATION_SIZE} bytes`
2408
+ );
2409
+ }
2410
+ const decompressed = decompress(compressed, void 0, dictionary);
2411
+ if (decompressed.length > MAX_DECOMPRESSED_LOCATION_SIZE) {
2412
+ throw new Error(
2413
+ `Decompressed location exceeds ${MAX_DECOMPRESSED_LOCATION_SIZE} bytes`
2414
+ );
2415
+ }
2416
+ return textDecoder.decode(decompressed);
2417
+ };
2418
+ }
2419
+ function parseArrayManifest(fbsArray, decodeLocation) {
1755
2420
  const nodeIdObj = fbsArray.nodeId();
1756
2421
  if (!nodeIdObj)
1757
2422
  throw new Error("ArrayManifest missing required node_id field");
@@ -1763,12 +2428,12 @@ function parseArrayManifest(fbsArray) {
1763
2428
  for (let i = 0; i < refsLength; i++) {
1764
2429
  const fbsRef = fbsArray.refs(i);
1765
2430
  if (fbsRef) {
1766
- refs.push(parseChunkRef(fbsRef));
2431
+ refs.push(parseChunkRef(fbsRef, decodeLocation));
1767
2432
  }
1768
2433
  }
1769
2434
  return { nodeId, refs };
1770
2435
  }
1771
- function parseChunkRef(fbsRef) {
2436
+ function parseChunkRef(fbsRef, decodeLocation) {
1772
2437
  const indexLength = fbsRef.indexLength();
1773
2438
  const index = [];
1774
2439
  for (let i = 0; i < indexLength; i++) {
@@ -1782,19 +2447,37 @@ function parseChunkRef(fbsRef) {
1782
2447
  const chunkId = chunkIdObj ? asObjectId12(
1783
2448
  chunkIdObj.bb.bytes().slice(chunkIdObj.bb_pos, chunkIdObj.bb_pos + 12)
1784
2449
  ) : null;
1785
- const location = fbsRef.location();
1786
2450
  const checksumEtag = fbsRef.checksumEtag();
1787
2451
  const checksumLastModified = fbsRef.checksumLastModified();
1788
- return {
2452
+ const ref = {
1789
2453
  index,
1790
2454
  inline,
1791
2455
  offset,
1792
2456
  length,
1793
2457
  chunkId,
1794
- location,
2458
+ location: fbsRef.location(),
1795
2459
  checksumEtag,
1796
2460
  checksumLastModified
1797
2461
  };
2462
+ if (chunkId === null) {
2463
+ const compressed = fbsRef.compressedLocationArray();
2464
+ if (compressed) {
2465
+ let decoded = null;
2466
+ let resolved = false;
2467
+ Object.defineProperty(ref, "location", {
2468
+ configurable: true,
2469
+ enumerable: true,
2470
+ get() {
2471
+ if (!resolved) {
2472
+ decoded = decodeLocation(compressed);
2473
+ resolved = true;
2474
+ }
2475
+ return decoded;
2476
+ }
2477
+ });
2478
+ }
2479
+ }
2480
+ return ref;
1798
2481
  }
1799
2482
  function findChunkRef(manifest, nodeId, coords) {
1800
2483
  const arrayManifest = binarySearchArrayManifest(manifest.arrays, nodeId);
@@ -1848,9 +2531,6 @@ function binarySearchChunkRef(refs, coords) {
1848
2531
  return null;
1849
2532
  }
1850
2533
  function getChunkPayload(ref) {
1851
- if (ref.inline !== null) {
1852
- return { type: "inline", data: ref.inline };
1853
- }
1854
2534
  if (ref.chunkId !== null) {
1855
2535
  return {
1856
2536
  type: "native",
@@ -1869,7 +2549,10 @@ function getChunkPayload(ref) {
1869
2549
  checksumLastModified: ref.checksumLastModified
1870
2550
  };
1871
2551
  }
1872
- throw new Error("Invalid ChunkRef: no inline, chunkId, or location");
2552
+ if (ref.inline !== null) {
2553
+ return { type: "inline", data: ref.inline };
2554
+ }
2555
+ throw new Error("Invalid ChunkRef: no chunkId, location, or inline");
1873
2556
  }
1874
2557
 
1875
2558
  // src/format/flatbuffers/metadata.ts
@@ -2454,7 +3137,7 @@ var ReadSession = class _ReadSession {
2454
3137
  validateFileType(header, 1 /* Snapshot */);
2455
3138
  let flatbufferData = getDataAfterHeader(data);
2456
3139
  if (header.compression === 1 /* Zstd */) {
2457
- flatbufferData = decompress2(flatbufferData);
3140
+ flatbufferData = decompress(flatbufferData);
2458
3141
  }
2459
3142
  return {
2460
3143
  snapshot: parseSnapshot(flatbufferData),
@@ -2492,7 +3175,7 @@ var ReadSession = class _ReadSession {
2492
3175
  validateFileType(header, 2 /* Manifest */);
2493
3176
  let flatbufferData = getDataAfterHeader(data);
2494
3177
  if (header.compression === 1 /* Zstd */) {
2495
- flatbufferData = decompress2(flatbufferData);
3178
+ flatbufferData = decompress(flatbufferData);
2496
3179
  }
2497
3180
  return parseManifest(flatbufferData);
2498
3181
  }
@@ -2556,7 +3239,7 @@ var ReadSession = class _ReadSession {
2556
3239
  validateFileType(header, 4 /* TransactionLog */);
2557
3240
  let flatbufferData = getDataAfterHeader(data);
2558
3241
  if (header.compression === 1 /* Zstd */) {
2559
- flatbufferData = decompress2(flatbufferData);
3242
+ flatbufferData = decompress(flatbufferData);
2560
3243
  }
2561
3244
  return parseTransactionLog(flatbufferData);
2562
3245
  }
@@ -3474,9 +4157,9 @@ var IcechunkStore = class _IcechunkStore {
3474
4157
  }
3475
4158
  });
3476
4159
  return chunk ?? void 0;
3477
- } catch (err) {
3478
- if (err instanceof NotFoundError) return void 0;
3479
- throw err;
4160
+ } catch (err2) {
4161
+ if (err2 instanceof NotFoundError) return void 0;
4162
+ throw err2;
3480
4163
  }
3481
4164
  }
3482
4165
  /**
@@ -3519,9 +4202,9 @@ var IcechunkStore = class _IcechunkStore {
3519
4202
  return data.slice(-range.suffixLength);
3520
4203
  }
3521
4204
  return data.slice(range.offset, range.offset + range.length);
3522
- } catch (err) {
3523
- if (err instanceof NotFoundError) return void 0;
3524
- throw err;
4205
+ } catch (err2) {
4206
+ if (err2 instanceof NotFoundError) return void 0;
4207
+ throw err2;
3525
4208
  }
3526
4209
  }
3527
4210
  /** Prepend basePath to a parsed path. */