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.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/
|
|
510
|
-
|
|
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
|
|
1234
|
+
const ab2 = configBytes.buffer.slice(
|
|
645
1235
|
configBytes.byteOffset,
|
|
646
1236
|
configBytes.byteOffset + configBytes.byteLength
|
|
647
1237
|
);
|
|
648
|
-
config = flexbuffers.toObject(
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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 =
|
|
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 (
|
|
3478
|
-
if (
|
|
3479
|
-
throw
|
|
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 (
|
|
3523
|
-
if (
|
|
3524
|
-
throw
|
|
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. */
|