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 +711 -28
- package/dist/index.cjs.map +1 -1
- package/dist/index.js +710 -27
- package/dist/index.js.map +1 -1
- package/package.json +2 -3
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/
|
|
563
|
-
var
|
|
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 =
|
|
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
|
|
1287
|
+
const ab2 = configBytes.buffer.slice(
|
|
698
1288
|
configBytes.byteOffset,
|
|
699
1289
|
configBytes.byteOffset + configBytes.byteLength
|
|
700
1290
|
);
|
|
701
|
-
config = flexbuffers.toObject(
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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 =
|
|
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 (
|
|
3531
|
-
if (
|
|
3532
|
-
throw
|
|
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 (
|
|
3576
|
-
if (
|
|
3577
|
-
throw
|
|
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. */
|