autosnippet 3.2.15 → 3.2.17

package/dist/lib/infrastructure/vector/HnswIndex.js

@@ -13,9 +13,7 @@
  * @module infrastructure/vector/HnswIndex
  */
 // ── 堆结构 ──
-/** @typedef {{ nodeIdx: number, dist: number }} HeapItem */
 class MinHeap {
-    /** @type {HeapItem[]} */
     #data = [];
     get size() {
         return this.#data.length;
@@ -75,7 +73,6 @@ class MinHeap {
     }
 }
 class MaxHeap {
-    /** @type {HeapItem[]} */
     #data = [];
     get size() {
         return this.#data.length;
@@ -154,13 +151,7 @@ export class HnswIndex {
     idToIndex = new Map();
     // ── 可选的自定义距离函数 (用于量化空间) ──
     #distanceFn = null;
-    /**
-     * @param {object} options
-     * @param {number} [options.M=16]
-     * @param {number} [options.efConstruct=200]
-     * @param {number} [options.efSearch=100]
-     * @param {function} [options.distanceFn] - 自定义距离函数 (a, b) => number
-     */
+    /** @param [options.distanceFn] 自定义距离函数 (a, b) => number */
     constructor(options = {}) {
         this.M = options.M || 16;
         this.M0 = this.M * 2;
@@ -171,18 +162,11 @@ export class HnswIndex {
             this.#distanceFn = options.distanceFn;
         }
     }
-    /**
-     * 获取节点数量
-     */
+    /** 获取节点数量 */
     get size() {
         return this.nodes.length;
     }
-    /**
-     * 余弦距离 = 1 - cosineSimilarity (越小越相似)
-     * @param {Float32Array|number[]} a
-     * @param {Float32Array|number[]} b
-     * @returns {number}
-     */
+    /** 余弦距离 = 1 - cosineSimilarity (越小越相似) */
     distance(a, b) {
         if (this.#distanceFn) {
             return this.#distanceFn(a, b);
@@ -192,27 +176,18 @@ export class HnswIndex {
     /**
      * 随机选取节点层级 (几何分布)
      * 使用 1 - Math.random() 避免 log(0) = -Infinity
-     * @returns {number}
      */
     #randomLevel() {
         // 1 - Math.random() ∈ (0, 1], 永远不会为 0
         return Math.floor(-Math.log(1 - Math.random()) * this.mL);
     }
-    /**
-     * 确保 graphs 数组至少有 level+1 层
-     * @param {number} level
-     */
+    /** 确保 graphs 数组至少有 level+1 层 */
     #ensureLevel(level) {
         while (this.graphs.length <= level) {
             this.graphs.push(new Map());
         }
     }
-    /**
-     * 获取节点在某层的邻居集合 (如不存在则创建)
-     * @param {number} level
-     * @param {number} nodeIdx
-     * @returns {Set<number>}
-     */
+    /** 获取节点在某层的邻居集合 (如不存在则创建) */
     #getNeighbors(level, nodeIdx) {
         const graph = this.graphs[level];
         if (!graph) {
@@ -227,10 +202,8 @@ export class HnswIndex {
     }
     /**
      * 插入一个向量到索引
-     * @param {string} id - 文档 ID
-     * @param {Float32Array|number[]} vector
-     * @param {object} [options]
-     * @param {Uint8Array} [options.qvector] - 预量化向量 (SQ8), 用于 2-pass 搜索加速
+     * @param id 文档 ID
+     * @param [options.qvector] 预量化向量 (SQ8), 用于 2-pass 搜索加速
      */
     addPoint(id, vector, options = {}) {
         // 如果 id 已存在, 先移除旧的 (支持更新)
@@ -285,7 +258,6 @@ export class HnswIndex {
     /**
      * 移除一个向量 (软删除: 断开所有连接但保留 slot)
      * 完整的 compaction 可在持久化时做
-     * @param {string} id
      */
     removePoint(id) {
         const nodeIdx = this.idToIndex.get(id);
@@ -322,9 +294,7 @@ export class HnswIndex {
             this.#findNewEntryPoint();
         }
     }
-    /**
-     * 查找新的入口点 (删除后)
-     */
+    /** 查找新的入口点 (删除后) */
     #findNewEntryPoint() {
         this.entryPoint = -1;
         this.maxLevel = -1;
@@ -336,10 +306,7 @@ export class HnswIndex {
             }
         }
     }
-    /**
-     * 为所有现有节点批量设置量化向量
-     * @param {import('./ScalarQuantizer.js').ScalarQuantizer} quantizer
-     */
+    /** 为所有现有节点批量设置量化向量 */
     setQuantizedVectors(quantizer) {
         for (const node of this.nodes) {
             if (node && node.vector.length > 0) {
@@ -355,12 +322,8 @@ export class HnswIndex {
      * - Phase 1-2: 使用 SQ8 量化距离图遍历 (快速粗排)
      * - Phase 3: 对候选用 Float32 精确余弦距离重排 (精排)
      *
-     * @param {Float32Array|number[]} queryVector
-     * @param {number} k
-     * @param {object} [options]
-     * @param {Uint8Array} [options.quantizedQuery] - SQ8 编码后的查询向量
-     * @param {import('./ScalarQuantizer.js').ScalarQuantizer} [options.quantizer]
-     * @returns {Array<{ id: string, nodeIdx: number, dist: number }>}
+     * @param [options.quantizedQuery] SQ8 编码后的查询向量
+     * @returns >}
      */
     searchKnn(queryVector, k = 10, options = {}) {
         if (this.entryPoint === -1 || this.nodes.length === 0) {
@@ -395,12 +358,9 @@ export class HnswIndex {
     }
     /**
      * 贪心搜索 — 在单一层级中找到离 query 最近的节点
-     * @param {Float32Array|number[]} query
-     * @param {number} entryNodeIdx
-     * @param {number} level
-     * @param {import('./ScalarQuantizer.js').ScalarQuantizer|null} quantizer - SQ8 量化器 (可选)
-     * @param {Uint8Array|null} quantizedQuery - SQ8 编码后的查询向量 (可选)
-     * @returns {number} 最近节点的 index
+     * @param quantizer SQ8 量化器 (可选)
+     * @param quantizedQuery SQ8 编码后的查询向量 (可选)
+     * @returns 最近节点的 index
      */
     #greedySearch(query, entryNodeIdx, level, quantizer = null, quantizedQuery = null) {
         let current = entryNodeIdx;
@@ -430,13 +390,8 @@ export class HnswIndex {
     }
     /**
      * searchLayer — HNSW 核心的宽度优先搜索
-     * @param {Float32Array|number[]} query
-     * @param {number} entryNodeIdx
-     * @param {number} ef - 搜索宽度
-     * @param {number} level
-     * @param {import('./ScalarQuantizer.js').ScalarQuantizer|null} quantizer
-     * @param {Uint8Array|null} quantizedQuery
-     * @returns {Array<{ nodeIdx: number, dist: number }>} 按距离升序排列
+     * @param ef 搜索宽度
+     * @returns >} 按距离升序排列
      */
     #searchLayer(query, entryNodeIdx, ef, level, quantizer = null, quantizedQuery = null) {
         const entryNode = this.nodes[entryNodeIdx];
@@ -484,11 +439,7 @@ export class HnswIndex {
     }
     /**
      * 距离计算: 优先使用 SQ8 量化距离, 降级到 Float32 精确距离
-     * @param {Float32Array|number[]} query
-     * @param {object} node - { vector, qvector? }
-     * @param {import('./ScalarQuantizer.js').ScalarQuantizer|null} quantizer
-     * @param {Uint8Array|null} quantizedQuery
-     * @returns {number}
+     * @param node { vector, qvector? }
      */
     #dist(query, node, quantizer, quantizedQuery) {
         if (quantizer && quantizedQuery && node.qvector) {
@@ -499,8 +450,7 @@ export class HnswIndex {
     /**
      * 简单邻居选择 — 取距离最近的 maxNeighbors 个
      * @param {Array<{ nodeIdx: number, dist: number }>} candidates
-     * @param {number} maxNeighbors
-     * @returns {Array<{ nodeIdx: number, dist: number }>}
+     * @returns >}
      */
     #selectNeighborsSimple(candidates, maxNeighbors) {
         return candidates.sort((a, b) => a.dist - b.dist).slice(0, maxNeighbors);
@@ -508,9 +458,6 @@ export class HnswIndex {
     /**
      * 裁剪节点的连接数到 maxNeighbors
      * 保留距离最近的邻居, 移除最远的
-     * @param {number} nodeIdx
-     * @param {number} level
-     * @param {number} maxNeighbors
      */
     #pruneConnections(nodeIdx, level, maxNeighbors) {
         const node = this.nodes[nodeIdx];
@@ -545,7 +492,7 @@ export class HnswIndex {
     // ── 序列化/反序列化 (供 BinaryPersistence 使用) ──
     /**
      * 导出索引状态 (用于持久化)
-     * @returns {{ nodes, graphs, entryPoint, maxLevel, M, M0, efConstruct, efSearch }}
+     * @returns }
      */
     serialize() {
         // 将 graphs Map<Set> 转为可序列化格式
@@ -570,8 +517,7 @@ export class HnswIndex {
     }
     /**
      * 从序列化数据恢复索引
-     * @param {object} data - serialize() 的返回值
-     * @returns {HnswIndex}
+     * @param data serialize() 的返回值
      */
     static deserialize(data) {
         const index = new HnswIndex({
@@ -609,9 +555,7 @@ export class HnswIndex {
             this.addPoint(item.id, item.vector);
         }
     }
-    /**
-     * 获取索引统计信息
-     */
+    /** 获取索引统计信息 */
     getStats() {
         const activeNodes = this.nodes.filter((n) => n !== null).length;
         let totalEdges = 0;
@@ -630,12 +574,7 @@ export class HnswIndex {
         };
     }
 }
-/**
- * 余弦距离 = 1 - cosineSimilarity
- * @param {Float32Array|number[]} a
- * @param {Float32Array|number[]} b
- * @returns {number}
- */
+/** 余弦距离 = 1 - cosineSimilarity */
 export function cosineDistance(a, b) {
     if (!a || !b || a.length === 0 || b.length === 0) {
         return 1;
@@ -657,4 +596,3 @@ export function cosineDistance(a, b) {
     return 1 - similarity;
 }
 export { MinHeap, MaxHeap };
-//# sourceMappingURL=HnswIndex.js.map

package/dist/lib/infrastructure/vector/HnswVectorAdapter.d.ts

@@ -18,17 +18,8 @@ import { VectorStore } from './VectorStore.js';
 export declare class HnswVectorAdapter extends VectorStore {
     #private;
     /**
-     * @param {string} projectRoot
-     * @param {object} [options]
-     * @param {number} [options.M=16]
-     * @param {number} [options.efConstruct=200]
-     * @param {number} [options.efSearch=100]
-     * @param {string} [options.quantize='auto'] - 'auto' | 'sq8' | 'none'
-     * @param {number} [options.quantizeThreshold=3000]
-     * @param {string} [options.indexDir]
-     * @param {number} [options.flushIntervalMs=2000]
-     * @param {number} [options.flushBatchSize=100]
-     * @param {boolean} [options.walEnabled=true] - 启用 WAL 持久化
+     * @param [options.quantize='auto'] 'auto' | 'sq8' | 'none'
+     * @param [options.walEnabled=true] 启用 WAL 持久化
      */
     constructor(projectRoot: string, options?: {
         M?: number;
@@ -109,9 +100,7 @@ export declare class HnswVectorAdapter extends VectorStore {
         vectorScore: number;
         keywordScore: number;
     }[]>;
-    /**
-     * query() — SearchEngine 使用的向量搜索别名
-     */
+    /** query() — SearchEngine 使用的向量搜索别名 */
     query(queryVector: number[] | Float32Array, topK?: number): Promise<{
         id: string | undefined;
         similarity: number;
@@ -136,13 +125,8 @@ export declare class HnswVectorAdapter extends VectorStore {
         quantized: boolean;
         dimension: number;
     }>;
-    /**
-     * 手动触发持久化 (测试/关闭时使用)
-     */
+    /** 手动触发持久化 (测试/关闭时使用) */
     flush(): Promise<void>;
-    /**
-     * 销毁: 清理定时器
-     */
+    /** 销毁: 清理定时器 */
     destroy(): void;
 }
-//# sourceMappingURL=HnswVectorAdapter.d.ts.map

package/dist/lib/infrastructure/vector/HnswVectorAdapter.js

@@ -23,13 +23,11 @@ import { HnswIndex } from './HnswIndex.js';
 import { ScalarQuantizer } from './ScalarQuantizer.js';
 import { VectorStore } from './VectorStore.js';
 export class HnswVectorAdapter extends VectorStore {
-    /** @type {HnswIndex} */
     #index;
     /** @type {Map<string, object>} id → metadata */
     #metadata;
     /** @type {Map<string, string>} id → content */
     #contents;
-    /** @type {ScalarQuantizer|null} */
     #quantizer;
     /** @type {number} 向量维度 (首次 upsert 自动检测) */
     #dimension = 0;
@@ -48,17 +46,8 @@ export class HnswVectorAdapter extends VectorStore {
     #indexDir;
     #indexPath; // .asvec 文件路径
     /**
-     * @param {string} projectRoot
-     * @param {object} [options]
-     * @param {number} [options.M=16]
-     * @param {number} [options.efConstruct=200]
-     * @param {number} [options.efSearch=100]
-     * @param {string} [options.quantize='auto'] - 'auto' | 'sq8' | 'none'
-     * @param {number} [options.quantizeThreshold=3000]
-     * @param {string} [options.indexDir]
-     * @param {number} [options.flushIntervalMs=2000]
-     * @param {number} [options.flushBatchSize=100]
-     * @param {boolean} [options.walEnabled=true] - 启用 WAL 持久化
+     * @param [options.quantize='auto'] 'auto' | 'sq8' | 'none'
+     * @param [options.walEnabled=true] 启用 WAL 持久化
      */
     constructor(projectRoot, options = {}) {
         super();
@@ -185,9 +174,7 @@ export class HnswVectorAdapter extends VectorStore {
         // 初始化 WAL
         this.#initWal();
     }
-    /**
-     * 同步从 JSON 索引迁移 (用于 initSync 路径)
-     */
+    /** 同步从 JSON 索引迁移 (用于 initSync 路径) */
     #syncMigrateFromJson() {
         const jsonPath = join(this.#indexDir, 'vector_index.json');
         if (!existsSync(jsonPath)) {
@@ -466,10 +453,7 @@ export class HnswVectorAdapter extends VectorStore {
     }
     /**
      * 关键词搜索 (BM25 简化版: token 匹配 + IDF 近似)
-     * @param {string} queryText
-     * @param {number} limit
-     * @param {object|null} filter
-     * @returns {Array<{ id: string, score: number }>}
+     * @returns >}
      */
     #keywordSearch(queryText, limit, filter) {
         if (!queryText) {
@@ -497,9 +481,7 @@ export class HnswVectorAdapter extends VectorStore {
         }
         return results.sort((a, b) => b.score - a.score).slice(0, limit);
     }
-    /**
-     * query() — SearchEngine 使用的向量搜索别名
-     */
+    /** query() — SearchEngine 使用的向量搜索别名 */
     async query(queryVector, topK = 10) {
         const results = await this.searchVector(queryVector, { topK });
         return results.map((r) => ({
@@ -555,9 +537,7 @@ export class HnswVectorAdapter extends VectorStore {
         };
     }
     // ── 持久化 ──
-    /**
-     * 初始化 WAL (Write-Ahead Log)
-     */
+    /** 初始化 WAL (Write-Ahead Log) */
     #initWal() {
         if (!this.#config.walEnabled) {
             return;
@@ -573,7 +553,7 @@ export class HnswVectorAdapter extends VectorStore {
     }
     /**
      * 重放 WAL 操作 (启动时恢复崩溃前未刷盘的操作)
-     * @param {object} op - WAL 操作
+     * @param op WAL 操作
      */
     #replayOp(op) {
         switch (op.t) {
@@ -611,9 +591,7 @@ export class HnswVectorAdapter extends VectorStore {
                 break;
         }
     }
-    /**
-     * 手动触发持久化 (测试/关闭时使用)
-     */
+    /** 手动触发持久化 (测试/关闭时使用) */
     async flush() {
         if (this.#wal) {
             await this.#wal.flush();
@@ -675,9 +653,7 @@ export class HnswVectorAdapter extends VectorStore {
         }
     }
     // ── 量化器 ──
-    /**
-     * 检查是否需要训练量化器, 训练后批量设置量化向量到 HNSW 节点
-     */
+    /** 检查是否需要训练量化器, 训练后批量设置量化向量到 HNSW 节点 */
     #maybeTrainQuantizer() {
         if (this.#config.quantize === 'none') {
             return;
@@ -734,9 +710,7 @@ export class HnswVectorAdapter extends VectorStore {
         }
         return true;
     }
-    /**
-     * 销毁: 清理定时器
-     */
+    /** 销毁: 清理定时器 */
     destroy() {
         // 清理 WAL
         if (this.#wal) {
@@ -764,4 +738,3 @@ export class HnswVectorAdapter extends VectorStore {
         }
     }
 }
-//# sourceMappingURL=HnswVectorAdapter.js.map

package/dist/lib/infrastructure/vector/IndexingPipeline.d.ts

@@ -50,8 +50,8 @@ export declare class IndexingPipeline {
     setContextualEnricher(enricher: ContextualEnricherLike | null): void;
     /**
      * 运行完整索引管线
-     * @param {object} options - { force: boolean, dryRun: boolean, onProgress: function }
-     * @returns {Promise<{ scanned, chunked, embedded, upserted, skipped, errors }>}
+     * @param options { force: boolean, dryRun: boolean, onProgress: function }
+     * @returns >}
      */
     run(options?: {
         force?: boolean;
@@ -72,17 +72,14 @@ export declare class IndexingPipeline {
     }>;
     /**
      * 扫描项目中的可索引文件
-     * @returns {Array<{ absolutePath, relativePath, type }>}
+     * @returns >}
      */
     scan(): {
         absolutePath: string;
         relativePath: string;
         type: string;
     }[];
-    /**
-     * 计算内容 hash
-     */
+    /** 计算内容 hash */
     hashContent(content: string): string;
 }
 export {};
-//# sourceMappingURL=IndexingPipeline.d.ts.map

package/dist/lib/infrastructure/vector/IndexingPipeline.js

@@ -78,8 +78,8 @@ export class IndexingPipeline {
     }
     /**
      * 运行完整索引管线
-     * @param {object} options - { force: boolean, dryRun: boolean, onProgress: function }
-     * @returns {Promise<{ scanned, chunked, embedded, upserted, skipped, errors }>}
+     * @param options { force: boolean, dryRun: boolean, onProgress: function }
+     * @returns >}
      */
     async run(options = {}) {
         const { force = false, dryRun = false, clear = false, onProgress } = options;
@@ -235,7 +235,7 @@ export class IndexingPipeline {
     }
     /**
      * 扫描项目中的可索引文件
-     * @returns {Array<{ absolutePath, relativePath, type }>}
+     * @returns >}
      */
     scan() {
         const files = [];
@@ -257,9 +257,7 @@ export class IndexingPipeline {
         }
         return files;
     }
-    /**
-     * 计算内容 hash
-     */
+    /** 计算内容 hash */
     hashContent(content) {
         return createHash('sha256').update(content).digest('hex').slice(0, 16);
     }
@@ -295,4 +293,3 @@ export class IndexingPipeline {
         return lang === 'unknown' ? 'text' : lang;
     }
 }
-//# sourceMappingURL=IndexingPipeline.js.map

package/dist/lib/infrastructure/vector/JsonVectorAdapter.d.ts

@@ -30,9 +30,7 @@ export declare class JsonVectorAdapter extends VectorStore {
     }>): Promise<void>;
     remove(id: string): Promise<void>;
     getById(id: string): Promise<any>;
-    /**
-     * 向量相似度搜索（余弦相似度）
-     */
+    /** 向量相似度搜索（余弦相似度） */
     searchVector(queryVector: number[], options?: {
         topK?: number;
         filter?: Record<string, unknown> | null;
@@ -41,9 +39,7 @@ export declare class JsonVectorAdapter extends VectorStore {
         item: any;
         score: number;
     }[]>;
-    /**
-     * 混合搜索：向量 70% + 关键词 30%
-     */
+    /** 混合搜索：向量 70% + 关键词 30% */
     hybridSearch(queryVector: number[], queryText: string, options?: {
         topK?: number;
         filter?: Record<string, unknown> | null;
@@ -77,4 +73,3 @@ export declare class JsonVectorAdapter extends VectorStore {
         hasVectors: number;
     }>;
 }
-//# sourceMappingURL=JsonVectorAdapter.d.ts.map

package/dist/lib/infrastructure/vector/JsonVectorAdapter.js

@@ -67,9 +67,7 @@ export class JsonVectorAdapter extends VectorStore {
     async getById(id) {
         return this.#data.get(id) || null;
     }
-    /**
-     * 向量相似度搜索（余弦相似度）
-     */
+    /** 向量相似度搜索（余弦相似度） */
     async searchVector(queryVector, options = {}) {
         const { topK = 10, filter = null, minScore = 0 } = options;
         if (!queryVector || queryVector.length === 0) {
@@ -92,9 +90,7 @@ export class JsonVectorAdapter extends VectorStore {
             .slice(0, topK);
         return scored;
     }
-    /**
-     * 混合搜索：向量 70% + 关键词 30%
-     */
+    /** 混合搜索：向量 70% + 关键词 30% */
     async hybridSearch(queryVector, queryText, options = {}) {
         const { topK = 10, filter = null } = options;
         let candidates = [...this.#data.values()];
@@ -250,4 +246,3 @@ export class JsonVectorAdapter extends VectorStore {
         }
     }
 }
-//# sourceMappingURL=JsonVectorAdapter.js.map

package/dist/lib/infrastructure/vector/ScalarQuantizer.d.ts

@@ -13,53 +13,33 @@
  */
 export declare class ScalarQuantizer {
     #private;
-    /**
-     * @param {number} dimension 向量维度
-     */
+    /** @param dimension 向量维度 */
     constructor(dimension: number);
     get dimension(): number;
     get trained(): boolean;
     /**
      * 训练量化器 — 从一批向量中统计 per-dimension min/max
-     * @param {Array<Float32Array|number[]>} vectors 训练集 (建议 ≥ 100 条)
+     * @param vectors 训练集 (建议 ≥ 100 条)
      */
     train(vectors: Array<Float32Array | number[]>): void;
-    /**
-     * 量化单个向量
-     * @param {Float32Array|number[]} vector
-     * @returns {Uint8Array}
-     */
+    /** 量化单个向量 */
     encode(vector: Float32Array | number[]): Uint8Array<ArrayBuffer>;
-    /**
-     * 批量量化
-     * @param {Array<Float32Array|number[]>} vectors
-     * @returns {Uint8Array[]}
-     */
+    /** 批量量化 */
     encodeBatch(vectors: Array<Float32Array | number[]>): Uint8Array<ArrayBuffer>[];
-    /**
-     * 反量化 (用于精排 re-rank)
-     * @param {Uint8Array} quantized
-     * @returns {Float32Array}
-     */
+    /** 反量化 (用于精排 re-rank) */
     decode(quantized: Uint8Array): Float32Array<ArrayBuffer>;
     /**
      * 量化空间内的距离计算 (避免反量化, 整数运算)
      * 使用 L2 on quantized space 近似余弦距离
      *
-     * @param {Uint8Array} a
-     * @param {Uint8Array} b
-     * @returns {number} 距离值 (越小越相似)
+     * @returns 距离值 (越小越相似)
      */
     distance(a: Uint8Array, b: Uint8Array): number;
     /**
      * 混合距离: 量化粗排 + 原始精排
      * 用于搜索时: 先用 SQ8 快速过滤, 再用 Float32 精确计算
      *
-     * @param {Uint8Array} quantizedA
-     * @param {Float32Array|number[]} originalA
-     * @param {Uint8Array} quantizedB
-     * @param {Float32Array|number[]} originalB
-     * @returns {{ coarse: number, fine: number }}
+     * @returns }
      */
     hybridDistance(quantizedA: Uint8Array, originalA: Float32Array | number[], quantizedB: Uint8Array, originalB: Float32Array | number[]): {
         coarse: number;
@@ -67,7 +47,7 @@ export declare class ScalarQuantizer {
     };
     /**
      * 序列化量化器参数
-     * @returns {{ dimension: number, mins: number[], maxs: number[] }}
+     * @returns }
      */
     serialize(): {
         dimension: number;
@@ -77,7 +57,6 @@ export declare class ScalarQuantizer {
     /**
      * 从序列化数据恢复量化器
      * @param {{ dimension: number, mins: number[], maxs: number[] }} data
-     * @returns {ScalarQuantizer}
      */
     static deserialize(data: {
         dimension: number;
@@ -85,4 +64,3 @@ export declare class ScalarQuantizer {
         maxs: number[];
     }): ScalarQuantizer;
 }
-//# sourceMappingURL=ScalarQuantizer.d.ts.map