@seekdb/bm25 1.2.0

package/dist/index.cjs

@@ -0,0 +1,277 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  Bm25EmbeddingFunction: () => Bm25EmbeddingFunction
+});
+module.exports = __toCommonJS(index_exports);
+var import_seekdb = require("seekdb");
+var import_snowball_stemmers = require("snowball-stemmers");
+var NAME = "bm25";
+var DEFAULT_K = 1.2;
+var DEFAULT_B = 0.75;
+var DEFAULT_AVG_DOC_LENGTH = 256;
+var DEFAULT_TOKEN_MAX_LENGTH = 40;
+var DEFAULT_MAX_DIMENSION = 5e5;
+var DEFAULT_STOPWORDS = [
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "he",
+  "in",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "that",
+  "the",
+  "to",
+  "was",
+  "were",
+  "will",
+  "with"
+];
+var ENGLISH_STEMMER = (0, import_snowball_stemmers.newStemmer)("english");
+var Murmur3AbsHasher = class {
+  constructor(seed = 0) {
+    this.seed = seed;
+  }
+  murmur3(key) {
+    let h1 = this.seed >>> 0;
+    const c1 = 3432918353;
+    const c2 = 461845907;
+    const bytes = key.length - (key.length & 3);
+    let i = 0;
+    while (i < bytes) {
+      let k12 = key.charCodeAt(i) & 255 | (key.charCodeAt(i + 1) & 255) << 8 | (key.charCodeAt(i + 2) & 255) << 16 | (key.charCodeAt(i + 3) & 255) << 24;
+      i += 4;
+      k12 = Math.imul(k12, c1);
+      k12 = k12 << 15 | k12 >>> 17;
+      k12 = Math.imul(k12, c2);
+      h1 ^= k12;
+      h1 = h1 << 13 | h1 >>> 19;
+      h1 = Math.imul(h1, 5) + 3864292196;
+    }
+    let k1 = 0;
+    switch (key.length & 3) {
+      case 3:
+        k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+      case 2:
+        k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+      case 1:
+        k1 ^= key.charCodeAt(i) & 255;
+        k1 = Math.imul(k1, c1);
+        k1 = k1 << 15 | k1 >>> 17;
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 2246822507);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 3266489909);
+    h1 ^= h1 >>> 16;
+    return h1 >>> 0;
+  }
+  hash(token) {
+    const unsigned = this.murmur3(token);
+    const signed = unsigned << 0 | 0;
+    return Math.abs(signed);
+  }
+};
+var Bm25Tokenizer = class {
+  constructor(stemmer, stopwords, tokenMaxLength) {
+    this.stemmer = stemmer;
+    this.tokenMaxLength = tokenMaxLength;
+    this.stopwords = new Set(
+      Array.from(stopwords, (word) => word.toLowerCase())
+    );
+  }
+  removeNonAlphanumeric(text) {
+    return text.replace(/[^\p{L}\p{N}_\s]+/gu, " ");
+  }
+  simpleTokenize(text) {
+    return text.toLowerCase().split(/\s+/u).filter(Boolean);
+  }
+  tokenize(text) {
+    const cleaned = this.removeNonAlphanumeric(text);
+    const rawTokens = this.simpleTokenize(cleaned);
+    const tokens = [];
+    for (const token of rawTokens) {
+      if (token.length === 0) continue;
+      if (this.stopwords.has(token)) continue;
+      if (token.length > this.tokenMaxLength) continue;
+      const stemmed = this.stemmer.stem(token).trim();
+      if (stemmed.length > 0) {
+        tokens.push(stemmed);
+      }
+    }
+    return tokens;
+  }
+};
+var Bm25EmbeddingFunction = class _Bm25EmbeddingFunction {
+  constructor(args = {}) {
+    this.name = NAME;
+    const {
+      k = DEFAULT_K,
+      b = DEFAULT_B,
+      avgDocLength = DEFAULT_AVG_DOC_LENGTH,
+      tokenMaxLength = DEFAULT_TOKEN_MAX_LENGTH,
+      maxDimension = DEFAULT_MAX_DIMENSION,
+      stopwords
+    } = args;
+    if (!Number.isFinite(k) || k <= 0) {
+      throw new import_seekdb.SeekdbValueError("k must be a positive finite number");
+    }
+    if (!Number.isFinite(b) || b < 0 || b > 1) {
+      throw new import_seekdb.SeekdbValueError("b must be a finite number in [0, 1]");
+    }
+    if (!Number.isFinite(avgDocLength) || avgDocLength <= 0) {
+      throw new import_seekdb.SeekdbValueError(
+        "avgDocLength must be a positive finite number"
+      );
+    }
+    if (!Number.isInteger(tokenMaxLength) || tokenMaxLength <= 0) {
+      throw new import_seekdb.SeekdbValueError("tokenMaxLength must be a positive integer");
+    }
+    if (!Number.isInteger(maxDimension) || maxDimension <= 0) {
+      throw new import_seekdb.SeekdbValueError("maxDimension must be a positive integer");
+    }
+    this.k = k;
+    this.b = b;
+    this.avgDocLength = avgDocLength;
+    this.tokenMaxLength = tokenMaxLength;
+    this.maxDimension = maxDimension;
+    this.customStopwords = stopwords ? [...stopwords] : void 0;
+    const stopwordList = this.customStopwords ?? [...DEFAULT_STOPWORDS];
+    this.tokenizer = new Bm25Tokenizer(
+      ENGLISH_STEMMER,
+      stopwordList,
+      tokenMaxLength
+    );
+    this.hasher = new Murmur3AbsHasher();
+  }
+  encode(text) {
+    const tokenList = this.tokenizer.tokenize(text);
+    if (tokenList.length === 0) {
+      return {};
+    }
+    const docLen = tokenList.length;
+    const counts = /* @__PURE__ */ new Map();
+    for (const token of tokenList) {
+      const tokenId = this.hasher.hash(token) % this.maxDimension;
+      counts.set(tokenId, (counts.get(tokenId) ?? 0) + 1);
+    }
+    const sparseVector = {};
+    for (const tokenId of Array.from(counts.keys()).sort((a, b) => a - b)) {
+      const tf = counts.get(tokenId);
+      const denominator = tf + this.k * (1 - this.b + this.b * docLen / this.avgDocLength);
+      sparseVector[tokenId] = tf * (this.k + 1) / denominator;
+    }
+    return sparseVector;
+  }
+  async generate(texts) {
+    if (!Array.isArray(texts)) {
+      throw new import_seekdb.SeekdbValueError("texts must be an array of strings");
+    }
+    if (texts.length === 0) {
+      return [];
+    }
+    return texts.map((text) => this.encode(text));
+  }
+  async generateForQueries(texts) {
+    return this.generate(texts);
+  }
+  getConfig() {
+    const config = {
+      k: this.k,
+      b: this.b,
+      avg_doc_length: this.avgDocLength,
+      token_max_length: this.tokenMaxLength,
+      max_dimension: this.maxDimension
+    };
+    if (this.customStopwords) {
+      config.stopwords = [...this.customStopwords];
+    }
+    return config;
+  }
+  validateConfigUpdate(newConfig) {
+    const mutableKeys = /* @__PURE__ */ new Set([
+      "k",
+      "b",
+      "avg_doc_length",
+      "token_max_length",
+      "max_dimension",
+      "stopwords"
+    ]);
+    for (const key of Object.keys(newConfig)) {
+      if (!mutableKeys.has(key)) {
+        throw new import_seekdb.SeekdbValueError(
+          `Updating '${key}' is not supported for ${NAME}`
+        );
+      }
+    }
+  }
+  static validateConfig(config) {
+    if (config.k !== void 0 && (!Number.isFinite(config.k) || config.k <= 0)) {
+      throw new import_seekdb.SeekdbValueError("k must be a positive finite number");
+    }
+    if (config.b !== void 0 && (!Number.isFinite(config.b) || config.b < 0 || config.b > 1)) {
+      throw new import_seekdb.SeekdbValueError("b must be a finite number in [0, 1]");
+    }
+    if (config.avg_doc_length !== void 0 && (!Number.isFinite(config.avg_doc_length) || config.avg_doc_length <= 0)) {
+      throw new import_seekdb.SeekdbValueError(
+        "avg_doc_length must be a positive finite number"
+      );
+    }
+    if (config.token_max_length !== void 0 && (!Number.isInteger(config.token_max_length) || config.token_max_length <= 0)) {
+      throw new import_seekdb.SeekdbValueError("token_max_length must be a positive integer");
+    }
+    if (config.max_dimension !== void 0 && (!Number.isInteger(config.max_dimension) || config.max_dimension <= 0)) {
+      throw new import_seekdb.SeekdbValueError("max_dimension must be a positive integer");
+    }
+  }
+  static buildFromConfig(config) {
+    _Bm25EmbeddingFunction.validateConfig(config);
+    return new _Bm25EmbeddingFunction({
+      k: config.k,
+      b: config.b,
+      avgDocLength: config.avg_doc_length,
+      tokenMaxLength: config.token_max_length,
+      maxDimension: config.max_dimension,
+      stopwords: config.stopwords
+    });
+  }
+};
+(0, import_seekdb.registerSparseEmbeddingFunction)(NAME, Bm25EmbeddingFunction);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Bm25EmbeddingFunction
+});

package/dist/index.d.cts

@@ -0,0 +1,40 @@
+import { EmbeddingConfig, SparseEmbeddingFunction, SparseVector } from 'seekdb';
+
+interface Bm25EmbeddingArgs extends EmbeddingConfig {
+    k?: number;
+    b?: number;
+    avgDocLength?: number;
+    tokenMaxLength?: number;
+    /** Max sparse dimension index. Default 500000. */
+    maxDimension?: number;
+    stopwords?: string[];
+}
+interface Bm25EmbeddingConfig extends EmbeddingConfig {
+    k?: number;
+    b?: number;
+    avg_doc_length?: number;
+    token_max_length?: number;
+    max_dimension?: number;
+    stopwords?: string[];
+}
+declare class Bm25EmbeddingFunction implements SparseEmbeddingFunction {
+    readonly name = "bm25";
+    private readonly tokenizer;
+    private readonly hasher;
+    private readonly k;
+    private readonly b;
+    private readonly avgDocLength;
+    private readonly tokenMaxLength;
+    private readonly maxDimension;
+    private readonly customStopwords?;
+    constructor(args?: Bm25EmbeddingArgs);
+    private encode;
+    generate(texts: string[]): Promise<SparseVector[]>;
+    generateForQueries(texts: string[]): Promise<SparseVector[]>;
+    getConfig(): Bm25EmbeddingConfig;
+    validateConfigUpdate(newConfig: Record<string, unknown>): void;
+    static validateConfig(config: Bm25EmbeddingConfig): void;
+    static buildFromConfig(config: Bm25EmbeddingConfig): Bm25EmbeddingFunction;
+}
+
+export { type Bm25EmbeddingArgs, type Bm25EmbeddingConfig, Bm25EmbeddingFunction };

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { EmbeddingConfig, SparseEmbeddingFunction, SparseVector } from 'seekdb';
+
+interface Bm25EmbeddingArgs extends EmbeddingConfig {
+    k?: number;
+    b?: number;
+    avgDocLength?: number;
+    tokenMaxLength?: number;
+    /** Max sparse dimension index. Default 500000. */
+    maxDimension?: number;
+    stopwords?: string[];
+}
+interface Bm25EmbeddingConfig extends EmbeddingConfig {
+    k?: number;
+    b?: number;
+    avg_doc_length?: number;
+    token_max_length?: number;
+    max_dimension?: number;
+    stopwords?: string[];
+}
+declare class Bm25EmbeddingFunction implements SparseEmbeddingFunction {
+    readonly name = "bm25";
+    private readonly tokenizer;
+    private readonly hasher;
+    private readonly k;
+    private readonly b;
+    private readonly avgDocLength;
+    private readonly tokenMaxLength;
+    private readonly maxDimension;
+    private readonly customStopwords?;
+    constructor(args?: Bm25EmbeddingArgs);
+    private encode;
+    generate(texts: string[]): Promise<SparseVector[]>;
+    generateForQueries(texts: string[]): Promise<SparseVector[]>;
+    getConfig(): Bm25EmbeddingConfig;
+    validateConfigUpdate(newConfig: Record<string, unknown>): void;
+    static validateConfig(config: Bm25EmbeddingConfig): void;
+    static buildFromConfig(config: Bm25EmbeddingConfig): Bm25EmbeddingFunction;
+}
+
+export { type Bm25EmbeddingArgs, type Bm25EmbeddingConfig, Bm25EmbeddingFunction };

package/dist/index.mjs

@@ -0,0 +1,255 @@
+// index.ts
+import {
+  registerSparseEmbeddingFunction,
+  SeekdbValueError
+} from "seekdb";
+import { newStemmer } from "snowball-stemmers";
+var NAME = "bm25";
+var DEFAULT_K = 1.2;
+var DEFAULT_B = 0.75;
+var DEFAULT_AVG_DOC_LENGTH = 256;
+var DEFAULT_TOKEN_MAX_LENGTH = 40;
+var DEFAULT_MAX_DIMENSION = 5e5;
+var DEFAULT_STOPWORDS = [
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "he",
+  "in",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "that",
+  "the",
+  "to",
+  "was",
+  "were",
+  "will",
+  "with"
+];
+var ENGLISH_STEMMER = newStemmer("english");
+var Murmur3AbsHasher = class {
+  constructor(seed = 0) {
+    this.seed = seed;
+  }
+  murmur3(key) {
+    let h1 = this.seed >>> 0;
+    const c1 = 3432918353;
+    const c2 = 461845907;
+    const bytes = key.length - (key.length & 3);
+    let i = 0;
+    while (i < bytes) {
+      let k12 = key.charCodeAt(i) & 255 | (key.charCodeAt(i + 1) & 255) << 8 | (key.charCodeAt(i + 2) & 255) << 16 | (key.charCodeAt(i + 3) & 255) << 24;
+      i += 4;
+      k12 = Math.imul(k12, c1);
+      k12 = k12 << 15 | k12 >>> 17;
+      k12 = Math.imul(k12, c2);
+      h1 ^= k12;
+      h1 = h1 << 13 | h1 >>> 19;
+      h1 = Math.imul(h1, 5) + 3864292196;
+    }
+    let k1 = 0;
+    switch (key.length & 3) {
+      case 3:
+        k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+      case 2:
+        k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+      case 1:
+        k1 ^= key.charCodeAt(i) & 255;
+        k1 = Math.imul(k1, c1);
+        k1 = k1 << 15 | k1 >>> 17;
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 2246822507);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 3266489909);
+    h1 ^= h1 >>> 16;
+    return h1 >>> 0;
+  }
+  hash(token) {
+    const unsigned = this.murmur3(token);
+    const signed = unsigned << 0 | 0;
+    return Math.abs(signed);
+  }
+};
+var Bm25Tokenizer = class {
+  constructor(stemmer, stopwords, tokenMaxLength) {
+    this.stemmer = stemmer;
+    this.tokenMaxLength = tokenMaxLength;
+    this.stopwords = new Set(
+      Array.from(stopwords, (word) => word.toLowerCase())
+    );
+  }
+  removeNonAlphanumeric(text) {
+    return text.replace(/[^\p{L}\p{N}_\s]+/gu, " ");
+  }
+  simpleTokenize(text) {
+    return text.toLowerCase().split(/\s+/u).filter(Boolean);
+  }
+  tokenize(text) {
+    const cleaned = this.removeNonAlphanumeric(text);
+    const rawTokens = this.simpleTokenize(cleaned);
+    const tokens = [];
+    for (const token of rawTokens) {
+      if (token.length === 0) continue;
+      if (this.stopwords.has(token)) continue;
+      if (token.length > this.tokenMaxLength) continue;
+      const stemmed = this.stemmer.stem(token).trim();
+      if (stemmed.length > 0) {
+        tokens.push(stemmed);
+      }
+    }
+    return tokens;
+  }
+};
+var Bm25EmbeddingFunction = class _Bm25EmbeddingFunction {
+  constructor(args = {}) {
+    this.name = NAME;
+    const {
+      k = DEFAULT_K,
+      b = DEFAULT_B,
+      avgDocLength = DEFAULT_AVG_DOC_LENGTH,
+      tokenMaxLength = DEFAULT_TOKEN_MAX_LENGTH,
+      maxDimension = DEFAULT_MAX_DIMENSION,
+      stopwords
+    } = args;
+    if (!Number.isFinite(k) || k <= 0) {
+      throw new SeekdbValueError("k must be a positive finite number");
+    }
+    if (!Number.isFinite(b) || b < 0 || b > 1) {
+      throw new SeekdbValueError("b must be a finite number in [0, 1]");
+    }
+    if (!Number.isFinite(avgDocLength) || avgDocLength <= 0) {
+      throw new SeekdbValueError(
+        "avgDocLength must be a positive finite number"
+      );
+    }
+    if (!Number.isInteger(tokenMaxLength) || tokenMaxLength <= 0) {
+      throw new SeekdbValueError("tokenMaxLength must be a positive integer");
+    }
+    if (!Number.isInteger(maxDimension) || maxDimension <= 0) {
+      throw new SeekdbValueError("maxDimension must be a positive integer");
+    }
+    this.k = k;
+    this.b = b;
+    this.avgDocLength = avgDocLength;
+    this.tokenMaxLength = tokenMaxLength;
+    this.maxDimension = maxDimension;
+    this.customStopwords = stopwords ? [...stopwords] : void 0;
+    const stopwordList = this.customStopwords ?? [...DEFAULT_STOPWORDS];
+    this.tokenizer = new Bm25Tokenizer(
+      ENGLISH_STEMMER,
+      stopwordList,
+      tokenMaxLength
+    );
+    this.hasher = new Murmur3AbsHasher();
+  }
+  encode(text) {
+    const tokenList = this.tokenizer.tokenize(text);
+    if (tokenList.length === 0) {
+      return {};
+    }
+    const docLen = tokenList.length;
+    const counts = /* @__PURE__ */ new Map();
+    for (const token of tokenList) {
+      const tokenId = this.hasher.hash(token) % this.maxDimension;
+      counts.set(tokenId, (counts.get(tokenId) ?? 0) + 1);
+    }
+    const sparseVector = {};
+    for (const tokenId of Array.from(counts.keys()).sort((a, b) => a - b)) {
+      const tf = counts.get(tokenId);
+      const denominator = tf + this.k * (1 - this.b + this.b * docLen / this.avgDocLength);
+      sparseVector[tokenId] = tf * (this.k + 1) / denominator;
+    }
+    return sparseVector;
+  }
+  async generate(texts) {
+    if (!Array.isArray(texts)) {
+      throw new SeekdbValueError("texts must be an array of strings");
+    }
+    if (texts.length === 0) {
+      return [];
+    }
+    return texts.map((text) => this.encode(text));
+  }
+  async generateForQueries(texts) {
+    return this.generate(texts);
+  }
+  getConfig() {
+    const config = {
+      k: this.k,
+      b: this.b,
+      avg_doc_length: this.avgDocLength,
+      token_max_length: this.tokenMaxLength,
+      max_dimension: this.maxDimension
+    };
+    if (this.customStopwords) {
+      config.stopwords = [...this.customStopwords];
+    }
+    return config;
+  }
+  validateConfigUpdate(newConfig) {
+    const mutableKeys = /* @__PURE__ */ new Set([
+      "k",
+      "b",
+      "avg_doc_length",
+      "token_max_length",
+      "max_dimension",
+      "stopwords"
+    ]);
+    for (const key of Object.keys(newConfig)) {
+      if (!mutableKeys.has(key)) {
+        throw new SeekdbValueError(
+          `Updating '${key}' is not supported for ${NAME}`
+        );
+      }
+    }
+  }
+  static validateConfig(config) {
+    if (config.k !== void 0 && (!Number.isFinite(config.k) || config.k <= 0)) {
+      throw new SeekdbValueError("k must be a positive finite number");
+    }
+    if (config.b !== void 0 && (!Number.isFinite(config.b) || config.b < 0 || config.b > 1)) {
+      throw new SeekdbValueError("b must be a finite number in [0, 1]");
+    }
+    if (config.avg_doc_length !== void 0 && (!Number.isFinite(config.avg_doc_length) || config.avg_doc_length <= 0)) {
+      throw new SeekdbValueError(
+        "avg_doc_length must be a positive finite number"
+      );
+    }
+    if (config.token_max_length !== void 0 && (!Number.isInteger(config.token_max_length) || config.token_max_length <= 0)) {
+      throw new SeekdbValueError("token_max_length must be a positive integer");
+    }
+    if (config.max_dimension !== void 0 && (!Number.isInteger(config.max_dimension) || config.max_dimension <= 0)) {
+      throw new SeekdbValueError("max_dimension must be a positive integer");
+    }
+  }
+  static buildFromConfig(config) {
+    _Bm25EmbeddingFunction.validateConfig(config);
+    return new _Bm25EmbeddingFunction({
+      k: config.k,
+      b: config.b,
+      avgDocLength: config.avg_doc_length,
+      tokenMaxLength: config.token_max_length,
+      maxDimension: config.max_dimension,
+      stopwords: config.stopwords
+    });
+  }
+};
+registerSparseEmbeddingFunction(NAME, Bm25EmbeddingFunction);
+export {
+  Bm25EmbeddingFunction
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@seekdb/bm25",
+  "version": "1.2.0",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@seekdb/common": "1.2.0",
+    "seekdb": "1.2.0"
+  },
+  "devDependencies": {
+    "@seekdb/common": "1.2.0",
+    "seekdb": "1.2.0"
+  },
+  "dependencies": {
+    "@types/snowball-stemmers": "^0.6.2",
+    "snowball-stemmers": "^0.6.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oceanbase/seekdb-js.git",
+    "directory": "packages/embeddings/bm25"
+  },
+  "homepage": "https://github.com/oceanbase/seekdb-js#readme",
+  "bugs": {
+    "url": "https://github.com/oceanbase/seekdb-js/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest"
+  }
+}