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.cjs +733 -40
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +20 -4
- package/dist/index.d.ts +20 -4
- package/dist/index.js +732 -39
- package/dist/index.js.map +1 -1
- package/package.json +5 -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,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(
|
|
2391
|
+
arrays.push(makeArrayManifest(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 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
|
|
1762
|
-
const
|
|
1763
|
-
|
|
1764
|
-
|
|
1765
|
-
|
|
1766
|
-
|
|
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
|
-
|
|
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
|
|
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(
|
|
2527
|
+
function binarySearchChunkRef(array, coords) {
|
|
1835
2528
|
let low = 0;
|
|
1836
|
-
let high =
|
|
2529
|
+
let high = array.numRefs - 1;
|
|
1837
2530
|
while (low <= high) {
|
|
1838
2531
|
const mid = Math.floor((low + high) / 2);
|
|
1839
|
-
const cmp = compareCoords(
|
|
2532
|
+
const cmp = compareCoords(array.refIndex(mid), coords);
|
|
1840
2533
|
if (cmp === 0) {
|
|
1841
|
-
return
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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 =
|
|
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 (
|
|
3478
|
-
if (
|
|
3479
|
-
throw
|
|
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 (
|
|
3523
|
-
if (
|
|
3524
|
-
throw
|
|
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. */
|