@bendyline/gezel-knowledge 1.2.11 → 1.2.12
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/browser.d.ts +77 -0
- package/dist/browser.js +1410 -0
- package/dist/index.d.ts +16 -330
- package/dist/index.js +66 -19
- package/dist/registry-xi2R42Av.d.ts +372 -0
- package/package.json +6 -2
|
@@ -0,0 +1,372 @@
|
|
|
1
|
+
import { KnowledgeEmbeddingProfile, KnowledgeChunkingProfile } from '@bendyline/gezk';
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* The canonical markdown chunker, parameterized over the two frozen
|
|
5
|
+
* profiles (the gezk spec §7):
|
|
6
|
+
*
|
|
7
|
+
* - `markdown-chunks@1` — unit 'chars', 4000/400: byte-for-byte the
|
|
8
|
+
* algorithm lifted from the project indexer
|
|
9
|
+
* (packages/service/src/index-store/docs.ts `chunkMarkdown` /
|
|
10
|
+
* `chunkLineRange`), so the service can later re-point here with zero
|
|
11
|
+
* behavior change.
|
|
12
|
+
* - `markdown-chunks@2` — unit 'tokens', 420/64: the knowledge
|
|
13
|
+
* profile. Token counting is injected (`countTokens` — the embedding
|
|
14
|
+
* profile's own tokenizer), packing is per-line with sentence-level
|
|
15
|
+
* splitting for oversized lines, and every chunk carries a structural
|
|
16
|
+
* `headingPath` (root→nearest, the section's own heading last).
|
|
17
|
+
*
|
|
18
|
+
* Pure functions, no I/O, no dependencies — importable by the compiler, the
|
|
19
|
+
* service indexer, and tests alike.
|
|
20
|
+
*/
|
|
21
|
+
interface MarkdownChunk {
|
|
22
|
+
kind: 'doc' | 'preamble' | 'section';
|
|
23
|
+
/** 1-based inclusive source line span. */
|
|
24
|
+
lineStart: number;
|
|
25
|
+
lineEnd: number;
|
|
26
|
+
text: string;
|
|
27
|
+
/** Raw heading texts, root → nearest (empty for preamble/doc chunks). */
|
|
28
|
+
headingPath: string[];
|
|
29
|
+
}
|
|
30
|
+
interface CharChunkerOptions {
|
|
31
|
+
unit: 'chars';
|
|
32
|
+
/** Max chunk size in characters (profile @1: 4000). */
|
|
33
|
+
target: number;
|
|
34
|
+
/** Overlap replayed between adjacent chunks, in characters (@1: 400). */
|
|
35
|
+
overlap: number;
|
|
36
|
+
}
|
|
37
|
+
interface TokenChunkerOptions {
|
|
38
|
+
unit: 'tokens';
|
|
39
|
+
/** Target chunk size in tokens (profile @2: 420). */
|
|
40
|
+
target: number;
|
|
41
|
+
/** Overlap in tokens (@2: 64). */
|
|
42
|
+
overlap: number;
|
|
43
|
+
/** The embedding profile's tokenizer — deterministic given its pinned digest. */
|
|
44
|
+
countTokens: (text: string) => number;
|
|
45
|
+
}
|
|
46
|
+
type ChunkerOptions = CharChunkerOptions | TokenChunkerOptions;
|
|
47
|
+
/** Split markdown into heading-aware, bounded, overlapping chunks. */
|
|
48
|
+
declare function chunkMarkdownProfile(md: string, opts: ChunkerOptions): MarkdownChunk[];
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* The exact text an embedder sees for one chunk (the gezk spec §5): the
|
|
52
|
+
* profile's passage instruction, a short context header naming the document
|
|
53
|
+
* and its heading path, then the chunk itself. The compiler and every live
|
|
54
|
+
* index build it here, so a passage embeds identically wherever it lives.
|
|
55
|
+
*/
|
|
56
|
+
/** `title\nheadingPath\n`, truncated to the header token budget (§5). */
|
|
57
|
+
declare function buildContextHeader(title: string, headingPath: readonly string[], maxTokens: number, countTokens: (text: string) => number): string;
|
|
58
|
+
interface PassageEmbedInput {
|
|
59
|
+
/** The embedding profile's passage instruction (often empty). */
|
|
60
|
+
readonly passageInstruction: string;
|
|
61
|
+
readonly title: string;
|
|
62
|
+
readonly headingPath: readonly string[];
|
|
63
|
+
readonly text: string;
|
|
64
|
+
/** The chunking profile's context-header budget, in tokens. */
|
|
65
|
+
readonly headerMaxTokens: number;
|
|
66
|
+
/** The embedding profile's tokenizer. */
|
|
67
|
+
readonly countTokens: (text: string) => number;
|
|
68
|
+
}
|
|
69
|
+
/** The passage text to embed for one chunk. */
|
|
70
|
+
declare function passageEmbedInput(input: PassageEmbedInput): string;
|
|
71
|
+
|
|
72
|
+
/**
|
|
73
|
+
* Measured cosine floors, the knowledge package's data so every reader
|
|
74
|
+
* (the inference host, a live index in a browser worker) applies the same
|
|
75
|
+
* numbers. Overrides for calibration live with the inference host.
|
|
76
|
+
*/
|
|
77
|
+
/**
|
|
78
|
+
* Cosine floors for knowledge-catalog vector hits.
|
|
79
|
+
*
|
|
80
|
+
* KNN has no notion of "no good answer": the nearest chunk comes back however
|
|
81
|
+
* far away it is, and the fused rank then scores it 1.0. A floor is what lets
|
|
82
|
+
* the vector arm say nothing. The project index learned this first
|
|
83
|
+
* (`VECTOR_ARM_MIN_SIMILARITY`); these are the same idea for catalogs.
|
|
84
|
+
*
|
|
85
|
+
* Keys are a catalog (`publisher/catalog`) or an embedding profile id; a
|
|
86
|
+
* catalog's own entry wins. A floor is a property of the embedder AND the
|
|
87
|
+
* corpus: multilingual-e5 scores unrelated text higher than bge-small scores
|
|
88
|
+
* a match, and bge-small's genuine matches sit at 0.57 in the project library
|
|
89
|
+
* but 0.69 in the Handboek. So the profile entries are defaults for catalogs
|
|
90
|
+
* nobody measured, and a catalog whose scale is known gets its own.
|
|
91
|
+
*
|
|
92
|
+
* A vector hit under its floor is not evidence: it neither ranks the document
|
|
93
|
+
* nor labels it `vector`. A profile with no floor at all keeps its hits for
|
|
94
|
+
* ranking but labels them `fts`, so proactive injection asks them to be
|
|
95
|
+
* grounded in a query term — an unmeasured scale is not trusted to vouch.
|
|
96
|
+
*
|
|
97
|
+
* Measured with the retrieval preview's `similarity` trace field; method and
|
|
98
|
+
* numbers in evals/src/retrieval-bench/KNOWLEDGE-CALIBRATION-2026-09-30.md.
|
|
99
|
+
* Re-measure on any profile or catalog change: these numbers do not travel.
|
|
100
|
+
*/
|
|
101
|
+
declare const KNOWLEDGE_VECTOR_FLOORS: Readonly<Record<string, number>>;
|
|
102
|
+
|
|
103
|
+
/**
|
|
104
|
+
* Stage-1 retrieval over a shard's sign-bit vectors, in memory. A full
|
|
105
|
+
* 200k-chunk shard is 9.6 MB of bits, and either scan below is one linear
|
|
106
|
+
* pass over them, a few milliseconds, needing nothing beyond plain SQLite
|
|
107
|
+
* to load — which is what lets any reader implement the format without a
|
|
108
|
+
* vector extension.
|
|
109
|
+
*
|
|
110
|
+
* Two scans share the bits:
|
|
111
|
+
* - `hammingTopK` — symmetric: the query is binarized too and rows are
|
|
112
|
+
* ranked by popcount(xor). The format's baseline (§2), and what the
|
|
113
|
+
* self-KNN smoke and the conformance kit exercise.
|
|
114
|
+
* - `asymmetricTopK` — the float query against each row's bits, ranked by
|
|
115
|
+
* Σ q[d]·(bit ? +1 : −1). Keeps the query's magnitudes, which on real
|
|
116
|
+
* embeddings roughly doubles the share of true neighbours a small
|
|
117
|
+
* candidate pool retains (measured on multilingual-e5-small: 22% → 39%
|
|
118
|
+
* of the exact top-24 at K = 192 with raw bits, 73% → 88% with centered
|
|
119
|
+
* bits). This is what `CatalogHandle` uses.
|
|
120
|
+
*/
|
|
121
|
+
interface ShardBitIndex {
|
|
122
|
+
/** Row-major sign-bit rows, `bytesPerRow` each; row i holds chunk_id i + 1. */
|
|
123
|
+
bits: Uint8Array;
|
|
124
|
+
bytesPerRow: number;
|
|
125
|
+
rows: number;
|
|
126
|
+
}
|
|
127
|
+
interface HammingHit {
|
|
128
|
+
chunkId: number;
|
|
129
|
+
distance: number;
|
|
130
|
+
}
|
|
131
|
+
/**
|
|
132
|
+
* The K nearest rows by hamming distance, ascending, ties broken by chunk
|
|
133
|
+
* id. Selection is a histogram over the (small, integer) distance range, so
|
|
134
|
+
* the whole query is two linear passes and no heap.
|
|
135
|
+
*/
|
|
136
|
+
declare function hammingTopK(index: ShardBitIndex, query: Uint8Array, k: number): HammingHit[];
|
|
137
|
+
interface AsymmetricHit {
|
|
138
|
+
chunkId: number;
|
|
139
|
+
score: number;
|
|
140
|
+
}
|
|
141
|
+
/**
|
|
142
|
+
* The K best rows by asymmetric score, descending, ties broken by chunk id.
|
|
143
|
+
*
|
|
144
|
+
* The score of a row is Σ_d query[d] · (bit_d ? +1 : −1). Per query a table
|
|
145
|
+
* of 256 partial sums is built for each byte position, so a row costs
|
|
146
|
+
* `bytesPerRow` table reads and adds — about the popcount scan's cost. The
|
|
147
|
+
* top-K is kept in a bounded min-heap whose root is the worst kept row.
|
|
148
|
+
*
|
|
149
|
+
* For a `centered-sign` profile the caller passes `query − center`; for a
|
|
150
|
+
* plain `sign` profile the unit query. The bits are whatever the catalog
|
|
151
|
+
* stored; this function does not know or care which.
|
|
152
|
+
*
|
|
153
|
+
* `excludedChunkIds` drops rows outright — media rows, which the text lane
|
|
154
|
+
* leaves to its own exact scan rather than letting them take candidate slots.
|
|
155
|
+
*/
|
|
156
|
+
declare function asymmetricTopK(index: ShardBitIndex, query: ArrayLike<number>, k: number, eligibleChunkIds?: ReadonlySet<number>, excludedChunkIds?: ReadonlySet<number>): AsymmetricHit[];
|
|
157
|
+
|
|
158
|
+
/**
|
|
159
|
+
* The registered embedding profiles — the single source both the compiler
|
|
160
|
+
* and the reader import. A profile is the FULL vector-space identity:
|
|
161
|
+
* readers refuse to mix vectors across profile ids, and any change to model,
|
|
162
|
+
* instructions, or encoding is a NEW id.
|
|
163
|
+
*
|
|
164
|
+
* Revisions are the Hugging Face commit hashes the profiles were frozen at
|
|
165
|
+
* (2026-08-20). The artifact digests (recorded 2026-09-03) are the sha256 of
|
|
166
|
+
* the exact files at those revisions — the Hub's LFS object ids for the ONNX
|
|
167
|
+
* graphs and the e5 tokenizer, a hashed download for the bge tokenizer — and
|
|
168
|
+
* name the full-precision graph explicitly, so the precision the vectors were
|
|
169
|
+
* produced at is a pinned fact rather than a runtime default. Every embedder
|
|
170
|
+
* built from a profile verifies the files it loaded against these digests.
|
|
171
|
+
*/
|
|
172
|
+
|
|
173
|
+
/**
|
|
174
|
+
* The public profile's first revision: multilingual, so world catalogs serve
|
|
175
|
+
* every reader. Superseded for new builds by MULTILINGUAL_E5_SMALL_2 (same
|
|
176
|
+
* vectors, centered stage-1 bits); catalogs built with this revision stay
|
|
177
|
+
* readable and searchable, at the lower stage-1 recall of raw sign bits.
|
|
178
|
+
*/
|
|
179
|
+
declare const MULTILINGUAL_E5_SMALL_1: KnowledgeEmbeddingProfile;
|
|
180
|
+
/**
|
|
181
|
+
* The public profile, revision 2: the model, files, instructions and int8
|
|
182
|
+
* rerank of revision 1, with the stage-1 sign bits taken from
|
|
183
|
+
* `vector − center` (`centered-sign`). e5-small vectors share one dominant
|
|
184
|
+
* direction, so raw sign bits mostly encode that direction rather than the
|
|
185
|
+
* passage and the hamming pre-filter loses most true neighbours; centering
|
|
186
|
+
* on the pinned corpus mean restores them (see e5-small-center.ts for the
|
|
187
|
+
* provenance and the measurements). A query vector for revision 1 is a
|
|
188
|
+
* valid query vector for revision 2 — `sameVectorSpace` says so — and the
|
|
189
|
+
* reader centers it itself from the catalog's profile echo.
|
|
190
|
+
*/
|
|
191
|
+
declare const MULTILINGUAL_E5_SMALL_2: KnowledgeEmbeddingProfile;
|
|
192
|
+
/** The local-build default — matches gezel's shipped project embedder. */
|
|
193
|
+
declare const BGE_SMALL_EN_V15_1: KnowledgeEmbeddingProfile;
|
|
194
|
+
declare const EMBEDDINGGEMMA_2_512_1: KnowledgeEmbeddingProfile;
|
|
195
|
+
/** Newest revision of a model first: `daemonEmbedderPin` picks the first match by repo. */
|
|
196
|
+
declare const KNOWLEDGE_EMBEDDING_PROFILES: readonly KnowledgeEmbeddingProfile[];
|
|
197
|
+
declare function knowledgeEmbeddingProfile(id: string): KnowledgeEmbeddingProfile | null;
|
|
198
|
+
/** What a profile's query model costs to download, or null for an unregistered profile. */
|
|
199
|
+
declare function knowledgeProfileQueryModelBytes(id: string): number | null;
|
|
200
|
+
/** The knowledge chunking profile: token-bounded, heading-aware Markdown sections. */
|
|
201
|
+
declare const MARKDOWN_CHUNKS_2: KnowledgeChunkingProfile;
|
|
202
|
+
/** @deprecated gezk 0.4 names; removed with the next minor. */
|
|
203
|
+
declare const GEZEL_MULTILINGUAL_E5_SMALL_1: {
|
|
204
|
+
id: string;
|
|
205
|
+
model: {
|
|
206
|
+
repo: string;
|
|
207
|
+
revision: string;
|
|
208
|
+
onnxFile?: string | undefined;
|
|
209
|
+
onnxDigest?: string | undefined;
|
|
210
|
+
files?: {
|
|
211
|
+
path: string;
|
|
212
|
+
digest?: string | undefined;
|
|
213
|
+
}[] | undefined;
|
|
214
|
+
};
|
|
215
|
+
tokenizer: {
|
|
216
|
+
kind: string;
|
|
217
|
+
file?: string | undefined;
|
|
218
|
+
digest?: string | undefined;
|
|
219
|
+
};
|
|
220
|
+
pooling: "mean" | "cls" | "last";
|
|
221
|
+
normalized: boolean;
|
|
222
|
+
dimensions: number;
|
|
223
|
+
maxTokens: number;
|
|
224
|
+
queryInstruction: string;
|
|
225
|
+
passageInstruction: string;
|
|
226
|
+
vectorEncoding: "bit+int8";
|
|
227
|
+
distance: {
|
|
228
|
+
stage1: "hamming";
|
|
229
|
+
stage2: "cosine";
|
|
230
|
+
};
|
|
231
|
+
quantization: {
|
|
232
|
+
int8: {
|
|
233
|
+
method: "symmetric-linear";
|
|
234
|
+
scale: 127;
|
|
235
|
+
};
|
|
236
|
+
binary: {
|
|
237
|
+
method: "sign" | "centered-sign";
|
|
238
|
+
threshold: 0;
|
|
239
|
+
packing: "lsb-first";
|
|
240
|
+
center?: number[] | undefined;
|
|
241
|
+
};
|
|
242
|
+
};
|
|
243
|
+
truncation?: {
|
|
244
|
+
method: "prefix";
|
|
245
|
+
sourceDimensions: number;
|
|
246
|
+
} | undefined;
|
|
247
|
+
media?: {
|
|
248
|
+
image?: {
|
|
249
|
+
encoder: {
|
|
250
|
+
onnxFile: string;
|
|
251
|
+
onnxDigest?: string | undefined;
|
|
252
|
+
files?: {
|
|
253
|
+
path: string;
|
|
254
|
+
digest?: string | undefined;
|
|
255
|
+
}[] | undefined;
|
|
256
|
+
};
|
|
257
|
+
tokenBudget: number;
|
|
258
|
+
resample: "bilinear" | "bicubic";
|
|
259
|
+
alpha: "composite-white";
|
|
260
|
+
} | undefined;
|
|
261
|
+
video?: {
|
|
262
|
+
framesPerSecond: number;
|
|
263
|
+
maxFrames: number;
|
|
264
|
+
tokenBudgetPerFrame: number;
|
|
265
|
+
} | undefined;
|
|
266
|
+
audio?: {
|
|
267
|
+
encoder: {
|
|
268
|
+
onnxFile: string;
|
|
269
|
+
onnxDigest?: string | undefined;
|
|
270
|
+
files?: {
|
|
271
|
+
path: string;
|
|
272
|
+
digest?: string | undefined;
|
|
273
|
+
}[] | undefined;
|
|
274
|
+
};
|
|
275
|
+
sampleRate: number;
|
|
276
|
+
channels: 1;
|
|
277
|
+
maxWindowMs: number;
|
|
278
|
+
} | undefined;
|
|
279
|
+
} | undefined;
|
|
280
|
+
};
|
|
281
|
+
/** @deprecated gezk 0.4 names; removed with the next minor. */
|
|
282
|
+
declare const GEZEL_BGE_SMALL_EN_V15_1: {
|
|
283
|
+
id: string;
|
|
284
|
+
model: {
|
|
285
|
+
repo: string;
|
|
286
|
+
revision: string;
|
|
287
|
+
onnxFile?: string | undefined;
|
|
288
|
+
onnxDigest?: string | undefined;
|
|
289
|
+
files?: {
|
|
290
|
+
path: string;
|
|
291
|
+
digest?: string | undefined;
|
|
292
|
+
}[] | undefined;
|
|
293
|
+
};
|
|
294
|
+
tokenizer: {
|
|
295
|
+
kind: string;
|
|
296
|
+
file?: string | undefined;
|
|
297
|
+
digest?: string | undefined;
|
|
298
|
+
};
|
|
299
|
+
pooling: "mean" | "cls" | "last";
|
|
300
|
+
normalized: boolean;
|
|
301
|
+
dimensions: number;
|
|
302
|
+
maxTokens: number;
|
|
303
|
+
queryInstruction: string;
|
|
304
|
+
passageInstruction: string;
|
|
305
|
+
vectorEncoding: "bit+int8";
|
|
306
|
+
distance: {
|
|
307
|
+
stage1: "hamming";
|
|
308
|
+
stage2: "cosine";
|
|
309
|
+
};
|
|
310
|
+
quantization: {
|
|
311
|
+
int8: {
|
|
312
|
+
method: "symmetric-linear";
|
|
313
|
+
scale: 127;
|
|
314
|
+
};
|
|
315
|
+
binary: {
|
|
316
|
+
method: "sign" | "centered-sign";
|
|
317
|
+
threshold: 0;
|
|
318
|
+
packing: "lsb-first";
|
|
319
|
+
center?: number[] | undefined;
|
|
320
|
+
};
|
|
321
|
+
};
|
|
322
|
+
truncation?: {
|
|
323
|
+
method: "prefix";
|
|
324
|
+
sourceDimensions: number;
|
|
325
|
+
} | undefined;
|
|
326
|
+
media?: {
|
|
327
|
+
image?: {
|
|
328
|
+
encoder: {
|
|
329
|
+
onnxFile: string;
|
|
330
|
+
onnxDigest?: string | undefined;
|
|
331
|
+
files?: {
|
|
332
|
+
path: string;
|
|
333
|
+
digest?: string | undefined;
|
|
334
|
+
}[] | undefined;
|
|
335
|
+
};
|
|
336
|
+
tokenBudget: number;
|
|
337
|
+
resample: "bilinear" | "bicubic";
|
|
338
|
+
alpha: "composite-white";
|
|
339
|
+
} | undefined;
|
|
340
|
+
video?: {
|
|
341
|
+
framesPerSecond: number;
|
|
342
|
+
maxFrames: number;
|
|
343
|
+
tokenBudgetPerFrame: number;
|
|
344
|
+
} | undefined;
|
|
345
|
+
audio?: {
|
|
346
|
+
encoder: {
|
|
347
|
+
onnxFile: string;
|
|
348
|
+
onnxDigest?: string | undefined;
|
|
349
|
+
files?: {
|
|
350
|
+
path: string;
|
|
351
|
+
digest?: string | undefined;
|
|
352
|
+
}[] | undefined;
|
|
353
|
+
};
|
|
354
|
+
sampleRate: number;
|
|
355
|
+
channels: 1;
|
|
356
|
+
maxWindowMs: number;
|
|
357
|
+
} | undefined;
|
|
358
|
+
} | undefined;
|
|
359
|
+
};
|
|
360
|
+
/** @deprecated gezk 0.4 names; removed with the next minor. */
|
|
361
|
+
declare const GEZEL_MARKDOWN_CHUNKS_2: {
|
|
362
|
+
id: string;
|
|
363
|
+
unit: "chars" | "tokens";
|
|
364
|
+
tokenizer: "profile" | "none";
|
|
365
|
+
target: number;
|
|
366
|
+
overlap: number;
|
|
367
|
+
contextHeader: {
|
|
368
|
+
max: number;
|
|
369
|
+
};
|
|
370
|
+
};
|
|
371
|
+
|
|
372
|
+
export { type AsymmetricHit as A, BGE_SMALL_EN_V15_1 as B, type CharChunkerOptions as C, EMBEDDINGGEMMA_2_512_1 as E, GEZEL_BGE_SMALL_EN_V15_1 as G, type HammingHit as H, KNOWLEDGE_EMBEDDING_PROFILES as K, MARKDOWN_CHUNKS_2 as M, type PassageEmbedInput as P, type ShardBitIndex as S, type TokenChunkerOptions as T, type ChunkerOptions as a, GEZEL_MARKDOWN_CHUNKS_2 as b, GEZEL_MULTILINGUAL_E5_SMALL_1 as c, KNOWLEDGE_VECTOR_FLOORS as d, MULTILINGUAL_E5_SMALL_1 as e, MULTILINGUAL_E5_SMALL_2 as f, type MarkdownChunk as g, asymmetricTopK as h, buildContextHeader as i, chunkMarkdownProfile as j, knowledgeEmbeddingProfile as k, knowledgeProfileQueryModelBytes as l, hammingTopK as m, passageEmbedInput as p };
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@bendyline/gezel-knowledge",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.12",
|
|
4
4
|
"description": "Gezel knowledge catalogs: the .gezk compiler, archive safety, read-only reader, routing, and signatures.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"keywords": [
|
|
@@ -40,6 +40,10 @@
|
|
|
40
40
|
".": {
|
|
41
41
|
"types": "./dist/index.d.ts",
|
|
42
42
|
"import": "./dist/index.js"
|
|
43
|
+
},
|
|
44
|
+
"./browser": {
|
|
45
|
+
"types": "./dist/browser.d.ts",
|
|
46
|
+
"import": "./dist/browser.js"
|
|
43
47
|
}
|
|
44
48
|
},
|
|
45
49
|
"files": [
|
|
@@ -47,7 +51,7 @@
|
|
|
47
51
|
"!dist/**/*.map"
|
|
48
52
|
],
|
|
49
53
|
"dependencies": {
|
|
50
|
-
"@bendyline/gezk": "1.0.
|
|
54
|
+
"@bendyline/gezk": "1.0.8",
|
|
51
55
|
"yaml": "^2.9.0",
|
|
52
56
|
"yauzl": "^3.4.0",
|
|
53
57
|
"yazl": "^3.3.1",
|