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.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,34 +2435,68 @@ 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(
|
|
2444
|
+
arrays.push(makeArrayManifest(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 makeArrayManifest(fbsArray, decodeLocation) {
|
|
1808
2473
|
const nodeIdObj = fbsArray.nodeId();
|
|
1809
2474
|
if (!nodeIdObj)
|
|
1810
2475
|
throw new Error("ArrayManifest missing required node_id field");
|
|
1811
2476
|
const nodeId = asObjectId8(
|
|
1812
2477
|
nodeIdObj.bb.bytes().slice(nodeIdObj.bb_pos, nodeIdObj.bb_pos + 8)
|
|
1813
2478
|
);
|
|
1814
|
-
const
|
|
1815
|
-
const
|
|
1816
|
-
|
|
1817
|
-
|
|
1818
|
-
|
|
1819
|
-
|
|
2479
|
+
const numRefs = fbsArray.refsLength();
|
|
2480
|
+
const probe = new ChunkRef();
|
|
2481
|
+
return {
|
|
2482
|
+
nodeId,
|
|
2483
|
+
numRefs,
|
|
2484
|
+
refIndex(i) {
|
|
2485
|
+
const fbsRef = fbsArray.refs(i, probe);
|
|
2486
|
+
if (!fbsRef) throw new Error(`Manifest ref ${i} out of range`);
|
|
2487
|
+
const indexLength = fbsRef.indexLength();
|
|
2488
|
+
const index = new Array(indexLength);
|
|
2489
|
+
for (let d = 0; d < indexLength; d++) index[d] = fbsRef.index(d);
|
|
2490
|
+
return index;
|
|
2491
|
+
},
|
|
2492
|
+
refAt(i) {
|
|
2493
|
+
const fbsRef = fbsArray.refs(i);
|
|
2494
|
+
if (!fbsRef) throw new Error(`Manifest ref ${i} out of range`);
|
|
2495
|
+
return parseChunkRef(fbsRef, decodeLocation);
|
|
1820
2496
|
}
|
|
1821
|
-
}
|
|
1822
|
-
return { nodeId, refs };
|
|
2497
|
+
};
|
|
1823
2498
|
}
|
|
1824
|
-
function parseChunkRef(fbsRef) {
|
|
2499
|
+
function parseChunkRef(fbsRef, decodeLocation) {
|
|
1825
2500
|
const indexLength = fbsRef.indexLength();
|
|
1826
2501
|
const index = [];
|
|
1827
2502
|
for (let i = 0; i < indexLength; i++) {
|
|
@@ -1835,24 +2510,42 @@ function parseChunkRef(fbsRef) {
|
|
|
1835
2510
|
const chunkId = chunkIdObj ? asObjectId12(
|
|
1836
2511
|
chunkIdObj.bb.bytes().slice(chunkIdObj.bb_pos, chunkIdObj.bb_pos + 12)
|
|
1837
2512
|
) : null;
|
|
1838
|
-
const location = fbsRef.location();
|
|
1839
2513
|
const checksumEtag = fbsRef.checksumEtag();
|
|
1840
2514
|
const checksumLastModified = fbsRef.checksumLastModified();
|
|
1841
|
-
|
|
2515
|
+
const ref = {
|
|
1842
2516
|
index,
|
|
1843
2517
|
inline,
|
|
1844
2518
|
offset,
|
|
1845
2519
|
length,
|
|
1846
2520
|
chunkId,
|
|
1847
|
-
location,
|
|
2521
|
+
location: fbsRef.location(),
|
|
1848
2522
|
checksumEtag,
|
|
1849
2523
|
checksumLastModified
|
|
1850
2524
|
};
|
|
2525
|
+
if (chunkId === null) {
|
|
2526
|
+
const compressed = fbsRef.compressedLocationArray();
|
|
2527
|
+
if (compressed) {
|
|
2528
|
+
let decoded = null;
|
|
2529
|
+
let resolved = false;
|
|
2530
|
+
Object.defineProperty(ref, "location", {
|
|
2531
|
+
configurable: true,
|
|
2532
|
+
enumerable: true,
|
|
2533
|
+
get() {
|
|
2534
|
+
if (!resolved) {
|
|
2535
|
+
decoded = decodeLocation(compressed);
|
|
2536
|
+
resolved = true;
|
|
2537
|
+
}
|
|
2538
|
+
return decoded;
|
|
2539
|
+
}
|
|
2540
|
+
});
|
|
2541
|
+
}
|
|
2542
|
+
}
|
|
2543
|
+
return ref;
|
|
1851
2544
|
}
|
|
1852
2545
|
function findChunkRef(manifest, nodeId, coords) {
|
|
1853
2546
|
const arrayManifest = binarySearchArrayManifest(manifest.arrays, nodeId);
|
|
1854
2547
|
if (!arrayManifest) return null;
|
|
1855
|
-
return binarySearchChunkRef(arrayManifest
|
|
2548
|
+
return binarySearchChunkRef(arrayManifest, coords);
|
|
1856
2549
|
}
|
|
1857
2550
|
function binarySearchArrayManifest(arrays, nodeId) {
|
|
1858
2551
|
let low = 0;
|
|
@@ -1884,14 +2577,14 @@ function compareCoords(a, b) {
|
|
|
1884
2577
|
}
|
|
1885
2578
|
return a.length - b.length;
|
|
1886
2579
|
}
|
|
1887
|
-
function binarySearchChunkRef(
|
|
2580
|
+
function binarySearchChunkRef(array, coords) {
|
|
1888
2581
|
let low = 0;
|
|
1889
|
-
let high =
|
|
2582
|
+
let high = array.numRefs - 1;
|
|
1890
2583
|
while (low <= high) {
|
|
1891
2584
|
const mid = Math.floor((low + high) / 2);
|
|
1892
|
-
const cmp = compareCoords(
|
|
2585
|
+
const cmp = compareCoords(array.refIndex(mid), coords);
|
|
1893
2586
|
if (cmp === 0) {
|
|
1894
|
-
return
|
|
2587
|
+
return array.refAt(mid);
|
|
1895
2588
|
} else if (cmp < 0) {
|
|
1896
2589
|
low = mid + 1;
|
|
1897
2590
|
} else {
|
|
@@ -1901,9 +2594,6 @@ function binarySearchChunkRef(refs, coords) {
|
|
|
1901
2594
|
return null;
|
|
1902
2595
|
}
|
|
1903
2596
|
function getChunkPayload(ref) {
|
|
1904
|
-
if (ref.inline !== null) {
|
|
1905
|
-
return { type: "inline", data: ref.inline };
|
|
1906
|
-
}
|
|
1907
2597
|
if (ref.chunkId !== null) {
|
|
1908
2598
|
return {
|
|
1909
2599
|
type: "native",
|
|
@@ -1922,7 +2612,10 @@ function getChunkPayload(ref) {
|
|
|
1922
2612
|
checksumLastModified: ref.checksumLastModified
|
|
1923
2613
|
};
|
|
1924
2614
|
}
|
|
1925
|
-
|
|
2615
|
+
if (ref.inline !== null) {
|
|
2616
|
+
return { type: "inline", data: ref.inline };
|
|
2617
|
+
}
|
|
2618
|
+
throw new Error("Invalid ChunkRef: no chunkId, location, or inline");
|
|
1926
2619
|
}
|
|
1927
2620
|
|
|
1928
2621
|
// src/format/flatbuffers/metadata.ts
|
|
@@ -2507,7 +3200,7 @@ var ReadSession = class _ReadSession {
|
|
|
2507
3200
|
validateFileType(header, 1 /* Snapshot */);
|
|
2508
3201
|
let flatbufferData = getDataAfterHeader(data);
|
|
2509
3202
|
if (header.compression === 1 /* Zstd */) {
|
|
2510
|
-
flatbufferData =
|
|
3203
|
+
flatbufferData = decompress(flatbufferData);
|
|
2511
3204
|
}
|
|
2512
3205
|
return {
|
|
2513
3206
|
snapshot: parseSnapshot(flatbufferData),
|
|
@@ -2545,7 +3238,7 @@ var ReadSession = class _ReadSession {
|
|
|
2545
3238
|
validateFileType(header, 2 /* Manifest */);
|
|
2546
3239
|
let flatbufferData = getDataAfterHeader(data);
|
|
2547
3240
|
if (header.compression === 1 /* Zstd */) {
|
|
2548
|
-
flatbufferData =
|
|
3241
|
+
flatbufferData = decompress(flatbufferData);
|
|
2549
3242
|
}
|
|
2550
3243
|
return parseManifest(flatbufferData);
|
|
2551
3244
|
}
|
|
@@ -2609,7 +3302,7 @@ var ReadSession = class _ReadSession {
|
|
|
2609
3302
|
validateFileType(header, 4 /* TransactionLog */);
|
|
2610
3303
|
let flatbufferData = getDataAfterHeader(data);
|
|
2611
3304
|
if (header.compression === 1 /* Zstd */) {
|
|
2612
|
-
flatbufferData =
|
|
3305
|
+
flatbufferData = decompress(flatbufferData);
|
|
2613
3306
|
}
|
|
2614
3307
|
return parseTransactionLog(flatbufferData);
|
|
2615
3308
|
}
|
|
@@ -3527,9 +4220,9 @@ var IcechunkStore = class _IcechunkStore {
|
|
|
3527
4220
|
}
|
|
3528
4221
|
});
|
|
3529
4222
|
return chunk ?? void 0;
|
|
3530
|
-
} catch (
|
|
3531
|
-
if (
|
|
3532
|
-
throw
|
|
4223
|
+
} catch (err2) {
|
|
4224
|
+
if (err2 instanceof NotFoundError) return void 0;
|
|
4225
|
+
throw err2;
|
|
3533
4226
|
}
|
|
3534
4227
|
}
|
|
3535
4228
|
/**
|
|
@@ -3572,9 +4265,9 @@ var IcechunkStore = class _IcechunkStore {
|
|
|
3572
4265
|
return data.slice(-range.suffixLength);
|
|
3573
4266
|
}
|
|
3574
4267
|
return data.slice(range.offset, range.offset + range.length);
|
|
3575
|
-
} catch (
|
|
3576
|
-
if (
|
|
3577
|
-
throw
|
|
4268
|
+
} catch (err2) {
|
|
4269
|
+
if (err2 instanceof NotFoundError) return void 0;
|
|
4270
|
+
throw err2;
|
|
3578
4271
|
}
|
|
3579
4272
|
}
|
|
3580
4273
|
/** Prepend basePath to a parsed path. */
|