v1.2.2 - Fix network error on background, auto-retry streaming with reconnect

node_modules/@kvs/storage/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 azu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@kvs/storage/README.md

@@ -0,0 +1,70 @@
+# @kvs/storage
+
+Storage-like for KVS.
+
+You can inject Storage object like localStorage, sessionStorage to this storage.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+    npm install @kvs/storage
+
+## Usage
+
+```ts
+import assert from "assert";
+import { kvsStorage } from "@kvs/storage";
+(async () => {
+    type StorageSchema = {
+        a1: string;
+        b2: number;
+        c3: boolean;
+    };
+    const storage = await kvsStorage<StorageSchema>({
+        name: "test",
+        version: 1,
+        storage: localStorage
+    });
+    await storage.set("a1", "string");
+    await storage.set("b2", 42);
+    await storage.set("c3", false);
+    const a1 = await storage.get("a1");
+    const b2 = await storage.get("b2");
+    const c3 = await storage.get("c3");
+    assert.strictEqual(a1, "string");
+    assert.strictEqual(b2, 42);
+    assert.strictEqual(c3, false);
+})();
+```
+
+## Changelog
+
+See [Releases page](https://github.com/azu/kvs/releases).
+
+## Running tests
+
+Install devDependencies and Run `npm test`:
+
+    npm test
+
+## Contributing
+
+Pull requests and stars are always welcome.
+
+For bugs and feature requests, [please create an issue](https://github.com/azu/kvs/issues).
+
+1. Fork it!
+2. Create your feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Submit a pull request :D
+
+## Author
+
+- [github/azu](https://github.com/azu)
+- [twitter/azu_re](https://twitter.com/azu_re)
+
+## License
+
+MIT © azu

node_modules/@kvs/storage/lib/JSONValue.d.ts

@@ -0,0 +1,16 @@
+/**
+ Matches a JSON object.
+ This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+ */
+export type JsonObject = {
+    [Key in string]?: JsonValue;
+};
+/**
+ Matches a JSON array.
+ */
+export interface JsonArray extends Array<JsonValue> {
+}
+/**
+ Matches any valid JSON value.
+ */
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;

node_modules/@kvs/storage/lib/JSONValue.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JSONValue.js.map

node_modules/@kvs/storage/lib/JSONValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONValue.js","sourceRoot":"","sources":["../src/JSONValue.ts"],"names":[],"mappings":""}

node_modules/@kvs/storage/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { kvsStorage, deleteItem, setItem, getItem, clearItem, createIterator, hasItem, KvsStorage, KVSStorageKey, KvsStorageOptions } from "./storage";
+export { JsonValue, JsonArray, JsonObject } from "./JSONValue";

node_modules/@kvs/storage/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasItem = exports.createIterator = exports.clearItem = exports.getItem = exports.setItem = exports.deleteItem = exports.kvsStorage = void 0;
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "kvsStorage", { enumerable: true, get: function () { return storage_1.kvsStorage; } });
+Object.defineProperty(exports, "deleteItem", { enumerable: true, get: function () { return storage_1.deleteItem; } });
+Object.defineProperty(exports, "setItem", { enumerable: true, get: function () { return storage_1.setItem; } });
+Object.defineProperty(exports, "getItem", { enumerable: true, get: function () { return storage_1.getItem; } });
+Object.defineProperty(exports, "clearItem", { enumerable: true, get: function () { return storage_1.clearItem; } });
+Object.defineProperty(exports, "createIterator", { enumerable: true, get: function () { return storage_1.createIterator; } });
+Object.defineProperty(exports, "hasItem", { enumerable: true, get: function () { return storage_1.hasItem; } });
+//# sourceMappingURL=index.js.map

node_modules/@kvs/storage/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAWmB;AAVf,qGAAA,UAAU,OAAA;AACV,qGAAA,UAAU,OAAA;AACV,kGAAA,OAAO,OAAA;AACP,kGAAA,OAAO,OAAA;AACP,oGAAA,SAAS,OAAA;AACT,yGAAA,cAAc,OAAA;AACd,kGAAA,OAAO,OAAA"}

node_modules/@kvs/storage/lib/storage.d.ts

@@ -0,0 +1,20 @@
+import type { KVS, KVSOptions, StoreNames, StoreValue } from "@kvs/types";
+import { JsonValue } from "./JSONValue";
+export type KVSStorageKey = string;
+export declare const getItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => any;
+export declare const hasItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => boolean;
+export declare const setItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>, value: StoreValue<Schema, StoreNames<Schema>> | undefined) => boolean | void;
+export declare const clearItem: (storage: Storage, tableName: string, kvsVersionKey: string, options: {
+    force: boolean;
+}) => void;
+export declare const deleteItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => boolean;
+export declare function createIterator<Schema extends StorageSchema>(storage: Storage, tableName: string, kvsVersionKey: string): Iterator<[StoreNames<Schema>, StoreValue<Schema, StoreNames<Schema>>]>;
+export type StorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsStorage<Schema extends StorageSchema> = KVS<Schema>;
+export type KvsStorageOptions<Schema extends StorageSchema> = KVSOptions<Schema> & {
+    kvsVersionKey?: string;
+    storage: Storage;
+};
+export declare const kvsStorage: <Schema extends StorageSchema>(options: KvsStorageOptions<Schema>) => Promise<KvsStorage<Schema>>;

node_modules/@kvs/storage/lib/storage.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kvsStorage = exports.deleteItem = exports.clearItem = exports.setItem = exports.hasItem = exports.getItem = void 0;
+exports.createIterator = createIterator;
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    throw new Error(message);
+}
+const TABLE_KEY_MARKER = ".__.";
+const getItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    const item = storage.getItem(storageKey);
+    return item !== null ? JSON.parse(item) : undefined;
+};
+exports.getItem = getItem;
+const hasItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    return storage.getItem(storageKey) !== null;
+};
+exports.hasItem = hasItem;
+const setItem = (storage, tableName, key, value) => {
+    // It is difference with IndexedDB implementation.
+    // This behavior compatible with localStorage.
+    if (value === undefined) {
+        return (0, exports.deleteItem)(storage, tableName, key);
+    }
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    return storage.setItem(storageKey, JSON.stringify(value));
+};
+exports.setItem = setItem;
+const clearItem = (storage, tableName, kvsVersionKey, options) => {
+    // TODO: kvsVersionKey is special type
+    const currentVersion = (0, exports.getItem)(storage, tableName, kvsVersionKey);
+    // clear all
+    storage.clear();
+    // if option.force is true, does not restore metadata.
+    if (options.force) {
+        return;
+    }
+    // set kvs version again
+    if (currentVersion !== undefined) {
+        (0, exports.setItem)(storage, tableName, kvsVersionKey, currentVersion);
+    }
+};
+exports.clearItem = clearItem;
+const deleteItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    try {
+        storage.removeItem(storageKey);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.deleteItem = deleteItem;
+function* createIterator(storage, tableName, kvsVersionKey) {
+    const tableKeyPrefix = `${tableName}${TABLE_KEY_MARKER}`;
+    for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (!key) {
+            continue;
+        }
+        // skip another storage
+        if (!key.startsWith(tableKeyPrefix)) {
+            continue;
+        }
+        // skip meta key
+        const keyWithoutPrefix = key.replace(tableKeyPrefix, "");
+        if (keyWithoutPrefix === kvsVersionKey) {
+            continue;
+        }
+        const value = (0, exports.getItem)(storage, tableName, keyWithoutPrefix);
+        yield [keyWithoutPrefix, value];
+    }
+}
+const DEFAULT_KVS_VERSION = 1;
+const openStorage = async ({ storage, version, tableName, kvsVersionKey, onUpgrade }) => {
+    // kvsVersionKey is special type
+    // first `oldVersion` is `0`
+    let oldVersion = (0, exports.getItem)(storage, tableName, kvsVersionKey);
+    if (oldVersion === undefined) {
+        (0, exports.setItem)(storage, tableName, kvsVersionKey, DEFAULT_KVS_VERSION);
+        // first `oldVersion` is `0`
+        // https://github.com/azu/kvs/issues/8
+        oldVersion = 0;
+    }
+    // if user set newVersion, upgrade it
+    if (oldVersion !== version) {
+        await onUpgrade({
+            oldVersion,
+            newVersion: version,
+            storage
+        });
+        // save current version if upgrade is success
+        (0, exports.setItem)(storage, tableName, kvsVersionKey, version);
+        return storage;
+    }
+    return storage;
+};
+const createStore = ({ tableName, storage, kvsVersionKey }) => {
+    const store = {
+        get(key) {
+            return Promise.resolve().then(() => {
+                return (0, exports.getItem)(storage, tableName, key);
+            });
+        },
+        has(key) {
+            return Promise.resolve().then(() => {
+                return (0, exports.hasItem)(storage, tableName, key);
+            });
+        },
+        set(key, value) {
+            return Promise.resolve()
+                .then(() => {
+                return (0, exports.setItem)(storage, tableName, key, value);
+            })
+                .then(() => {
+                return store;
+            });
+        },
+        clear() {
+            return Promise.resolve().then(() => {
+                return (0, exports.clearItem)(storage, tableName, kvsVersionKey, { force: false });
+            });
+        },
+        delete(key) {
+            return Promise.resolve().then(() => {
+                return (0, exports.deleteItem)(storage, tableName, key);
+            });
+        },
+        dropInstance() {
+            return Promise.resolve().then(() => {
+                return (0, exports.clearItem)(storage, tableName, kvsVersionKey, { force: true });
+            });
+        },
+        close() {
+            // Noop function
+            return Promise.resolve();
+        },
+        [Symbol.asyncIterator]() {
+            const iterator = createIterator(storage, tableName, kvsVersionKey);
+            return {
+                next() {
+                    return Promise.resolve().then(() => {
+                        return iterator.next();
+                    });
+                }
+            };
+        }
+    };
+    return store;
+};
+const kvsStorage = async (options) => {
+    var _a;
+    const { name, version, upgrade, ...kvStorageOptions } = options;
+    invariant(typeof name === "string", "name should be string");
+    invariant(name.length > 0, "name should not be empty");
+    invariant(!name.includes(TABLE_KEY_MARKER), `name can not include ${TABLE_KEY_MARKER}. It is reserved in kvs.`);
+    invariant(typeof version === "number", `version should be number`);
+    const kvsVersionKey = (_a = kvStorageOptions.kvsVersionKey) !== null && _a !== void 0 ? _a : "__kvs_version__";
+    const storage = await openStorage({
+        storage: options.storage,
+        version: options.version,
+        tableName: name,
+        onUpgrade: ({ oldVersion, newVersion, storage }) => {
+            if (!options.upgrade) {
+                return;
+            }
+            return options.upgrade({
+                kvs: createStore({ tableName: name, storage, kvsVersionKey }),
+                oldVersion,
+                newVersion
+            });
+        },
+        kvsVersionKey
+    });
+    return createStore({ tableName: name, storage, kvsVersionKey });
+};
+exports.kvsStorage = kvsStorage;
+//# sourceMappingURL=storage.js.map

node_modules/@kvs/storage/module/JSONValue.d.ts

@@ -0,0 +1,16 @@
+/**
+ Matches a JSON object.
+ This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+ */
+export type JsonObject = {
+    [Key in string]?: JsonValue;
+};
+/**
+ Matches a JSON array.
+ */
+export interface JsonArray extends Array<JsonValue> {
+}
+/**
+ Matches any valid JSON value.
+ */
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;

node_modules/@kvs/storage/module/JSONValue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=JSONValue.js.map

node_modules/@kvs/storage/module/JSONValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONValue.js","sourceRoot":"","sources":["../src/JSONValue.ts"],"names":[],"mappings":""}

node_modules/@kvs/storage/module/index.d.ts

@@ -0,0 +1,2 @@
+export { kvsStorage, deleteItem, setItem, getItem, clearItem, createIterator, hasItem, KvsStorage, KVSStorageKey, KvsStorageOptions } from "./storage";
+export { JsonValue, JsonArray, JsonObject } from "./JSONValue";

node_modules/@kvs/storage/module/index.js

@@ -0,0 +1,2 @@
+export { kvsStorage, deleteItem, setItem, getItem, clearItem, createIterator, hasItem } from "./storage";
+//# sourceMappingURL=index.js.map

node_modules/@kvs/storage/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,UAAU,EACV,OAAO,EACP,OAAO,EACP,SAAS,EACT,cAAc,EACd,OAAO,EAIV,MAAM,WAAW,CAAC"}

node_modules/@kvs/storage/module/storage.d.ts

@@ -0,0 +1,20 @@
+import type { KVS, KVSOptions, StoreNames, StoreValue } from "@kvs/types";
+import { JsonValue } from "./JSONValue";
+export type KVSStorageKey = string;
+export declare const getItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => any;
+export declare const hasItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => boolean;
+export declare const setItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>, value: StoreValue<Schema, StoreNames<Schema>> | undefined) => boolean | void;
+export declare const clearItem: (storage: Storage, tableName: string, kvsVersionKey: string, options: {
+    force: boolean;
+}) => void;
+export declare const deleteItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => boolean;
+export declare function createIterator<Schema extends StorageSchema>(storage: Storage, tableName: string, kvsVersionKey: string): Iterator<[StoreNames<Schema>, StoreValue<Schema, StoreNames<Schema>>]>;
+export type StorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsStorage<Schema extends StorageSchema> = KVS<Schema>;
+export type KvsStorageOptions<Schema extends StorageSchema> = KVSOptions<Schema> & {
+    kvsVersionKey?: string;
+    storage: Storage;
+};
+export declare const kvsStorage: <Schema extends StorageSchema>(options: KvsStorageOptions<Schema>) => Promise<KvsStorage<Schema>>;

node_modules/@kvs/storage/module/storage.js

@@ -0,0 +1,173 @@
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    throw new Error(message);
+}
+const TABLE_KEY_MARKER = ".__.";
+export const getItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    const item = storage.getItem(storageKey);
+    return item !== null ? JSON.parse(item) : undefined;
+};
+export const hasItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    return storage.getItem(storageKey) !== null;
+};
+export const setItem = (storage, tableName, key, value) => {
+    // It is difference with IndexedDB implementation.
+    // This behavior compatible with localStorage.
+    if (value === undefined) {
+        return deleteItem(storage, tableName, key);
+    }
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    return storage.setItem(storageKey, JSON.stringify(value));
+};
+export const clearItem = (storage, tableName, kvsVersionKey, options) => {
+    // TODO: kvsVersionKey is special type
+    const currentVersion = getItem(storage, tableName, kvsVersionKey);
+    // clear all
+    storage.clear();
+    // if option.force is true, does not restore metadata.
+    if (options.force) {
+        return;
+    }
+    // set kvs version again
+    if (currentVersion !== undefined) {
+        setItem(storage, tableName, kvsVersionKey, currentVersion);
+    }
+};
+export const deleteItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    try {
+        storage.removeItem(storageKey);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+export function* createIterator(storage, tableName, kvsVersionKey) {
+    const tableKeyPrefix = `${tableName}${TABLE_KEY_MARKER}`;
+    for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (!key) {
+            continue;
+        }
+        // skip another storage
+        if (!key.startsWith(tableKeyPrefix)) {
+            continue;
+        }
+        // skip meta key
+        const keyWithoutPrefix = key.replace(tableKeyPrefix, "");
+        if (keyWithoutPrefix === kvsVersionKey) {
+            continue;
+        }
+        const value = getItem(storage, tableName, keyWithoutPrefix);
+        yield [keyWithoutPrefix, value];
+    }
+}
+const DEFAULT_KVS_VERSION = 1;
+const openStorage = async ({ storage, version, tableName, kvsVersionKey, onUpgrade }) => {
+    // kvsVersionKey is special type
+    // first `oldVersion` is `0`
+    let oldVersion = getItem(storage, tableName, kvsVersionKey);
+    if (oldVersion === undefined) {
+        setItem(storage, tableName, kvsVersionKey, DEFAULT_KVS_VERSION);
+        // first `oldVersion` is `0`
+        // https://github.com/azu/kvs/issues/8
+        oldVersion = 0;
+    }
+    // if user set newVersion, upgrade it
+    if (oldVersion !== version) {
+        await onUpgrade({
+            oldVersion,
+            newVersion: version,
+            storage
+        });
+        // save current version if upgrade is success
+        setItem(storage, tableName, kvsVersionKey, version);
+        return storage;
+    }
+    return storage;
+};
+const createStore = ({ tableName, storage, kvsVersionKey }) => {
+    const store = {
+        get(key) {
+            return Promise.resolve().then(() => {
+                return getItem(storage, tableName, key);
+            });
+        },
+        has(key) {
+            return Promise.resolve().then(() => {
+                return hasItem(storage, tableName, key);
+            });
+        },
+        set(key, value) {
+            return Promise.resolve()
+                .then(() => {
+                return setItem(storage, tableName, key, value);
+            })
+                .then(() => {
+                return store;
+            });
+        },
+        clear() {
+            return Promise.resolve().then(() => {
+                return clearItem(storage, tableName, kvsVersionKey, { force: false });
+            });
+        },
+        delete(key) {
+            return Promise.resolve().then(() => {
+                return deleteItem(storage, tableName, key);
+            });
+        },
+        dropInstance() {
+            return Promise.resolve().then(() => {
+                return clearItem(storage, tableName, kvsVersionKey, { force: true });
+            });
+        },
+        close() {
+            // Noop function
+            return Promise.resolve();
+        },
+        [Symbol.asyncIterator]() {
+            const iterator = createIterator(storage, tableName, kvsVersionKey);
+            return {
+                next() {
+                    return Promise.resolve().then(() => {
+                        return iterator.next();
+                    });
+                }
+            };
+        }
+    };
+    return store;
+};
+export const kvsStorage = async (options) => {
+    var _a;
+    const { name, version, upgrade, ...kvStorageOptions } = options;
+    invariant(typeof name === "string", "name should be string");
+    invariant(name.length > 0, "name should not be empty");
+    invariant(!name.includes(TABLE_KEY_MARKER), `name can not include ${TABLE_KEY_MARKER}. It is reserved in kvs.`);
+    invariant(typeof version === "number", `version should be number`);
+    const kvsVersionKey = (_a = kvStorageOptions.kvsVersionKey) !== null && _a !== void 0 ? _a : "__kvs_version__";
+    const storage = await openStorage({
+        storage: options.storage,
+        version: options.version,
+        tableName: name,
+        onUpgrade: ({ oldVersion, newVersion, storage }) => {
+            if (!options.upgrade) {
+                return;
+            }
+            return options.upgrade({
+                kvs: createStore({ tableName: name, storage, kvsVersionKey }),
+                oldVersion,
+                newVersion
+            });
+        },
+        kvsVersionKey
+    });
+    return createStore({ tableName: name, storage, kvsVersionKey });
+};
+//# sourceMappingURL=storage.js.map

node_modules/@kvs/storage/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@kvs/storage",
+  "version": "2.2.2",
+  "description": "Storage(localStorage, sessionStorage) helper for KVS.",
+  "keywords": [
+    "kvs",
+    "browser",
+    "localstorage"
+  ],
+  "homepage": "https://github.com/azu/kvs/tree/master/packages/storage/",
+  "bugs": {
+    "url": "https://github.com/azu/kvs/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/azu/kvs.git"
+  },
+  "license": "MIT",
+  "author": "azu",
+  "sideEffects": false,
+  "main": "lib/index.js",
+  "module": "module/index.js",
+  "types": "lib/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "module"
+  ],
+  "scripts": {
+    "build": "tsc -p . && tsc --project ./tsconfig.module.json",
+    "clean": "rimraf lib/ module/",
+    "prettier": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "tsc -p .",
+    "test:browser": "npm run test:chrome && npm run test:firefox && npm run test:webkit",
+    "test:chrome": "playwright-test ./test/index.test.ts --runner=mocha --browser=chromium",
+    "test:firefox": "playwright-test ./test/index.test.ts --runner=mocha --browser=firefox",
+    "test:webkit": "playwright-test ./test/index.test.ts --runner=mocha --browser=webkit",
+    "watch": "tsc -p . --watch"
+  },
+  "prettier": {
+    "printWidth": 120,
+    "singleQuote": false,
+    "tabWidth": 4,
+    "trailingComma": "none"
+  },
+  "dependencies": {
+    "@kvs/types": "^2.2.2"
+  },
+  "devDependencies": {
+    "@kvs/common-test-case": "^2.2.2",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.4.2",
+    "mocha": "^10.2.0",
+    "playwright-test": "^14.1.12",
+    "prettier": "^3.0.0",
+    "rimraf": "^5.0.1",
+    "ts-loader": "^9.4.4",
+    "typescript": "^5.1.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "d8a7098f37e551532dbcc8c411fe26ec493cd898"
+}