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.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,34 +2382,68 @@ 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(makeArrayManifest(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 makeArrayManifest(fbsArray, decodeLocation) {
1755
2420
  const nodeIdObj = fbsArray.nodeId();
1756
2421
  if (!nodeIdObj)
1757
2422
  throw new Error("ArrayManifest missing required node_id field");
1758
2423
  const nodeId = asObjectId8(
1759
2424
  nodeIdObj.bb.bytes().slice(nodeIdObj.bb_pos, nodeIdObj.bb_pos + 8)
1760
2425
  );
1761
- const refsLength = fbsArray.refsLength();
1762
- const refs = [];
1763
- for (let i = 0; i < refsLength; i++) {
1764
- const fbsRef = fbsArray.refs(i);
1765
- if (fbsRef) {
1766
- refs.push(parseChunkRef(fbsRef));
2426
+ const numRefs = fbsArray.refsLength();
2427
+ const probe = new ChunkRef();
2428
+ return {
2429
+ nodeId,
2430
+ numRefs,
2431
+ refIndex(i) {
2432
+ const fbsRef = fbsArray.refs(i, probe);
2433
+ if (!fbsRef) throw new Error(`Manifest ref ${i} out of range`);
2434
+ const indexLength = fbsRef.indexLength();
2435
+ const index = new Array(indexLength);
2436
+ for (let d = 0; d < indexLength; d++) index[d] = fbsRef.index(d);
2437
+ return index;
2438
+ },
2439
+ refAt(i) {
2440
+ const fbsRef = fbsArray.refs(i);
2441
+ if (!fbsRef) throw new Error(`Manifest ref ${i} out of range`);
2442
+ return parseChunkRef(fbsRef, decodeLocation);
1767
2443
  }
1768
- }
1769
- return { nodeId, refs };
2444
+ };
1770
2445
  }
1771
- function parseChunkRef(fbsRef) {
2446
+ function parseChunkRef(fbsRef, decodeLocation) {
1772
2447
  const indexLength = fbsRef.indexLength();
1773
2448
  const index = [];
1774
2449
  for (let i = 0; i < indexLength; i++) {
@@ -1782,24 +2457,42 @@ function parseChunkRef(fbsRef) {
1782
2457
  const chunkId = chunkIdObj ? asObjectId12(
1783
2458
  chunkIdObj.bb.bytes().slice(chunkIdObj.bb_pos, chunkIdObj.bb_pos + 12)
1784
2459
  ) : null;
1785
- const location = fbsRef.location();
1786
2460
  const checksumEtag = fbsRef.checksumEtag();
1787
2461
  const checksumLastModified = fbsRef.checksumLastModified();
1788
- return {
2462
+ const ref = {
1789
2463
  index,
1790
2464
  inline,
1791
2465
  offset,
1792
2466
  length,
1793
2467
  chunkId,
1794
- location,
2468
+ location: fbsRef.location(),
1795
2469
  checksumEtag,
1796
2470
  checksumLastModified
1797
2471
  };
2472
+ if (chunkId === null) {
2473
+ const compressed = fbsRef.compressedLocationArray();
2474
+ if (compressed) {
2475
+ let decoded = null;
2476
+ let resolved = false;
2477
+ Object.defineProperty(ref, "location", {
2478
+ configurable: true,
2479
+ enumerable: true,
2480
+ get() {
2481
+ if (!resolved) {
2482
+ decoded = decodeLocation(compressed);
2483
+ resolved = true;
2484
+ }
2485
+ return decoded;
2486
+ }
2487
+ });
2488
+ }
2489
+ }
2490
+ return ref;
1798
2491
  }
1799
2492
  function findChunkRef(manifest, nodeId, coords) {
1800
2493
  const arrayManifest = binarySearchArrayManifest(manifest.arrays, nodeId);
1801
2494
  if (!arrayManifest) return null;
1802
- return binarySearchChunkRef(arrayManifest.refs, coords);
2495
+ return binarySearchChunkRef(arrayManifest, coords);
1803
2496
  }
1804
2497
  function binarySearchArrayManifest(arrays, nodeId) {
1805
2498
  let low = 0;
@@ -1831,14 +2524,14 @@ function compareCoords(a, b) {
1831
2524
  }
1832
2525
  return a.length - b.length;
1833
2526
  }
1834
- function binarySearchChunkRef(refs, coords) {
2527
+ function binarySearchChunkRef(array, coords) {
1835
2528
  let low = 0;
1836
- let high = refs.length - 1;
2529
+ let high = array.numRefs - 1;
1837
2530
  while (low <= high) {
1838
2531
  const mid = Math.floor((low + high) / 2);
1839
- const cmp = compareCoords(refs[mid].index, coords);
2532
+ const cmp = compareCoords(array.refIndex(mid), coords);
1840
2533
  if (cmp === 0) {
1841
- return refs[mid];
2534
+ return array.refAt(mid);
1842
2535
  } else if (cmp < 0) {
1843
2536
  low = mid + 1;
1844
2537
  } else {
@@ -1848,9 +2541,6 @@ function binarySearchChunkRef(refs, coords) {
1848
2541
  return null;
1849
2542
  }
1850
2543
  function getChunkPayload(ref) {
1851
- if (ref.inline !== null) {
1852
- return { type: "inline", data: ref.inline };
1853
- }
1854
2544
  if (ref.chunkId !== null) {
1855
2545
  return {
1856
2546
  type: "native",
@@ -1869,7 +2559,10 @@ function getChunkPayload(ref) {
1869
2559
  checksumLastModified: ref.checksumLastModified
1870
2560
  };
1871
2561
  }
1872
- throw new Error("Invalid ChunkRef: no inline, chunkId, or location");
2562
+ if (ref.inline !== null) {
2563
+ return { type: "inline", data: ref.inline };
2564
+ }
2565
+ throw new Error("Invalid ChunkRef: no chunkId, location, or inline");
1873
2566
  }
1874
2567
 
1875
2568
  // src/format/flatbuffers/metadata.ts
@@ -2454,7 +3147,7 @@ var ReadSession = class _ReadSession {
2454
3147
  validateFileType(header, 1 /* Snapshot */);
2455
3148
  let flatbufferData = getDataAfterHeader(data);
2456
3149
  if (header.compression === 1 /* Zstd */) {
2457
- flatbufferData = decompress2(flatbufferData);
3150
+ flatbufferData = decompress(flatbufferData);
2458
3151
  }
2459
3152
  return {
2460
3153
  snapshot: parseSnapshot(flatbufferData),
@@ -2492,7 +3185,7 @@ var ReadSession = class _ReadSession {
2492
3185
  validateFileType(header, 2 /* Manifest */);
2493
3186
  let flatbufferData = getDataAfterHeader(data);
2494
3187
  if (header.compression === 1 /* Zstd */) {
2495
- flatbufferData = decompress2(flatbufferData);
3188
+ flatbufferData = decompress(flatbufferData);
2496
3189
  }
2497
3190
  return parseManifest(flatbufferData);
2498
3191
  }
@@ -2556,7 +3249,7 @@ var ReadSession = class _ReadSession {
2556
3249
  validateFileType(header, 4 /* TransactionLog */);
2557
3250
  let flatbufferData = getDataAfterHeader(data);
2558
3251
  if (header.compression === 1 /* Zstd */) {
2559
- flatbufferData = decompress2(flatbufferData);
3252
+ flatbufferData = decompress(flatbufferData);
2560
3253
  }
2561
3254
  return parseTransactionLog(flatbufferData);
2562
3255
  }
@@ -3474,9 +4167,9 @@ var IcechunkStore = class _IcechunkStore {
3474
4167
  }
3475
4168
  });
3476
4169
  return chunk ?? void 0;
3477
- } catch (err) {
3478
- if (err instanceof NotFoundError) return void 0;
3479
- throw err;
4170
+ } catch (err2) {
4171
+ if (err2 instanceof NotFoundError) return void 0;
4172
+ throw err2;
3480
4173
  }
3481
4174
  }
3482
4175
  /**
@@ -3519,9 +4212,9 @@ var IcechunkStore = class _IcechunkStore {
3519
4212
  return data.slice(-range.suffixLength);
3520
4213
  }
3521
4214
  return data.slice(range.offset, range.offset + range.length);
3522
- } catch (err) {
3523
- if (err instanceof NotFoundError) return void 0;
3524
- throw err;
4215
+ } catch (err2) {
4216
+ if (err2 instanceof NotFoundError) return void 0;
4217
+ throw err2;
3525
4218
  }
3526
4219
  }
3527
4220
  /** Prepend basePath to a parsed path. */