added doga

25_02_24/node_modules/lowdb/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 typicode
+
+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.

25_02_24/node_modules/lowdb/README.md

@@ -0,0 +1,404 @@
+# lowdb [![](http://img.shields.io/npm/dm/lowdb.svg?style=flat)](https://www.npmjs.org/package/lowdb) [![Node.js CI](https://github.com/typicode/lowdb/actions/workflows/node.js.yml/badge.svg)](https://github.com/typicode/lowdb/actions/workflows/node.js.yml)
+
+> Simple to use type-safe local JSON database 🦉
+
+Read or create `db.json`
+
+```js
+const db = await JSONFilePreset('db.json', { posts: [] })
+```
+
+Update data using `Array.prototype.*` and automatically write to `db.json`
+
+```js
+const post = { id: 1, title: 'lowdb is awesome', views: 100 }
+await db.update(({ posts }) => posts.push(post))
+```
+
+```js
+// db.json
+{
+  "posts": [
+    { "id": 1, "title": "lowdb is awesome", "views": 100 }
+  ]
+}
+```
+
+In the same spirit, query using native `Array.prototype.*`
+
+```js
+const { posts } = db.data
+const first = posts.at(0)
+const results = posts.filter((post) => post.title.includes('lowdb'))
+const post1 = posts.find((post) => post.id === 1)
+const sortedPosts = posts.toSorted((a, b) => a.views - b.views)
+```
+
+It's that simple.
+
+## Sponsors
+
+<br>
+<br>
+
+<p align="center">
+  <a href="https://mockend.com/" target="_blank">
+    <img src="https://jsonplaceholder.typicode.com/mockend.svg" height="70px">
+  </a>
+</p>
+
+<br>
+<br>
+
+[Become a sponsor and have your company logo here](https://github.com/sponsors/typicode) 👉 [GitHub Sponsors](https://github.com/sponsors/typicode)
+
+## Features
+
+- **Lightweight**
+- **Minimalist**
+- **TypeScript**
+- **Plain JavaScript**
+- Safe atomic writes
+- Hackable:
+  - Change storage, file format (JSON, YAML, ...) or add encryption via [adapters](#adapters)
+  - Extend it with lodash, ramda, ... for super powers!
+- Automatically switches to fast in-memory mode during tests
+
+## Install
+
+```sh
+npm install lowdb
+```
+
+## Usage
+
+_Lowdb is a pure ESM package. If you're having trouble using it in your project, please [read this](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c)._
+
+```js
+import { JSONFilePreset } from 'lowdb/node'
+
+// Read or create db.json
+const defaultData = { posts: [] }
+const db = await JSONFilePreset('db.json', defaultData)
+
+// Update db.json
+await db.update(({ posts }) => posts.push('hello world'))
+
+// Alternatively you can call db.write() explicitely later
+// to write to db.json
+db.data.posts.push('hello world')
+await db.write()
+```
+
+```js
+// db.json
+{
+  "posts": [ "hello world" ]
+}
+```
+
+### TypeScript
+
+You can use TypeScript to check your data types.
+
+```ts
+type Data = {
+  messages: string[]
+}
+
+const defaultData: Data = { messages: [] }
+const db = await JSONPreset<Data>('db.json', defaultData)
+
+db.data.messages.push('foo') // ✅ Success
+db.data.messages.push(1) // ❌ TypeScript error
+```
+
+### Lodash
+
+You can extend lowdb with Lodash (or other libraries). To be able to extend it, we're not using `JSONPreset` here. Instead, we're using lower components.
+
+```ts
+import { Low } from 'lowdb'
+import { JSONFile } from 'lowdb/node'
+import lodash from 'lodash'
+
+type Post = {
+  id: number
+  title: string
+}
+
+type Data = {
+  posts: Post[]
+}
+
+// Extend Low class with a new `chain` field
+class LowWithLodash<T> extends Low<T> {
+  chain: lodash.ExpChain<this['data']> = lodash.chain(this).get('data')
+}
+
+const defaultData: Data = {
+  posts: [],
+}
+const adapter = new JSONFile<Data>('db.json', defaultData)
+
+const db = new LowWithLodash(adapter)
+await db.read()
+
+// Instead of db.data use db.chain to access lodash API
+const post = db.chain.get('posts').find({ id: 1 }).value() // Important: value() must be called to execute chain
+```
+
+### CLI, Server, Browser and in tests usage
+
+See [`src/examples/`](src/examples) directory.
+
+## API
+
+### Presets
+
+Lowdb provides four presets for common cases.
+
+- `JSONFilePreset(filename, defaultData)`
+- `JSONFileSyncPreset(filename, defaultData)`
+- `LocalStoragePreset(name, defaultData)`
+- `SessionStoragePreset(name, defaultData)`
+
+See [`src/examples/`](src/examples) directory for usage.
+
+Lowdb is extremely flexible, if you need to extend it or modify its behavior, use the classes and adapters below instead of the presets.
+
+### Classes
+
+Lowdb has two classes (for asynchronous and synchronous adapters).
+
+#### `new Low(adapter, defaultData)`
+
+```js
+import { Low } from 'lowdb'
+import { JSONFile } from 'lowdb/node'
+
+const db = new Low(new JSONFile('file.json'), {})
+await db.read()
+await db.write()
+```
+
+#### `new LowSync(adapterSync, defaultData)`
+
+```js
+import { LowSync } from 'lowdb'
+import { JSONFileSync } from 'lowdb/node'
+
+const db = new LowSync(new JSONFileSync('file.json'), {})
+db.read()
+db.write()
+```
+
+### Methods
+
+#### `db.read()`
+
+Calls `adapter.read()` and sets `db.data`.
+
+**Note:** `JSONFile` and `JSONFileSync` adapters will set `db.data` to `null` if file doesn't exist.
+
+```js
+db.data // === null
+db.read()
+db.data // !== null
+```
+
+#### `db.write()`
+
+Calls `adapter.write(db.data)`.
+
+```js
+db.data = { posts: [] }
+db.write() // file.json will be { posts: [] }
+db.data = {}
+db.write() // file.json will be {}
+```
+
+#### `db.update(fn)`
+
+Calls `fn()` then `db.write()`.
+
+```js
+db.update((data) => {
+  // make changes to data
+  // ...
+})
+// files.json will be updated
+```
+
+### Properties
+
+#### `db.data`
+
+Holds your db content. If you're using the adapters coming with lowdb, it can be any type supported by [`JSON.stringify`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify).
+
+For example:
+
+```js
+db.data = 'string'
+db.data = [1, 2, 3]
+db.data = { key: 'value' }
+```
+
+## Adapters
+
+### Lowdb adapters
+
+#### `JSONFile` `JSONFileSync`
+
+Adapters for reading and writing JSON files.
+
+```js
+import { JSONFile, JSONFileSync } from 'lowdb/node'
+
+new Low(new JSONFile(filename), {})
+new LowSync(new JSONFileSync(filename), {})
+```
+
+#### `Memory` `MemorySync`
+
+In-memory adapters. Useful for speeding up unit tests. See [`src/examples/`](src/examples) directory.
+
+```js
+import { Memory, MemorySync } from 'lowdb'
+
+new Low(new Memory(), {})
+new LowSync(new MemorySync(), {})
+```
+
+#### `LocalStorage` `SessionStorage`
+
+Synchronous adapter for `window.localStorage` and `window.sessionStorage`.
+
+```js
+import { LocalStorage, SessionStorage } from 'lowdb/browser'
+new LowSync(new LocalStorage(name), {})
+new LowSync(new SessionStorage(name), {})
+```
+
+### Utility adapters
+
+#### `TextFile` `TextFileSync`
+
+Adapters for reading and writing text. Useful for creating custom adapters.
+
+#### `DataFile` `DataFileSync`
+
+Adapters for easily supporting other data formats or adding behaviors (encrypt, compress...).
+
+```js
+import { DataFile } from 'lowdb'
+new DataFile(filename, {
+  parse: YAML.parse,
+  stringify: YAML.stringify
+})
+new DataFile(filename, {
+  parse: (data) => { decypt(JSON.parse(data)) },
+  stringify: (str) => { encrypt(JSON.stringify(str)) }
+})
+```
+
+### Third-party adapters
+
+If you've published an adapter for lowdb, feel free to create a PR to add it here.
+
+### Writing your own adapter
+
+You may want to create an adapter to write `db.data` to YAML, XML, encrypt data, a remote storage, ...
+
+An adapter is a simple class that just needs to expose two methods:
+
+```js
+class AsyncAdapter {
+  read() {
+    /* ... */
+  } // should return Promise<data>
+  write(data) {
+    /* ... */
+  } // should return Promise<void>
+}
+
+class SyncAdapter {
+  read() {
+    /* ... */
+  } // should return data
+  write(data) {
+    /* ... */
+  } // should return nothing
+}
+```
+
+For example, let's say you have some async storage and want to create an adapter for it:
+
+```js
+import { api } from './AsyncStorage'
+
+class CustomAsyncAdapter {
+  // Optional: your adapter can take arguments
+  constructor(args) {
+    // ...
+  }
+
+  async read() {
+    const data = await api.read()
+    return data
+  }
+
+  async write(data) {
+    await api.write(data)
+  }
+}
+
+const adapter = new CustomAsyncAdapter()
+const db = new Low(adapter)
+```
+
+See [`src/adapters/`](src/adapters) for more examples.
+
+#### Custom serialization
+
+To create an adapter for another format than JSON, you can use `TextFile` or `TextFileSync`.
+
+For example:
+
+```js
+import { Adapter, Low } from 'lowdb'
+import { TextFile } from 'lowdb/node'
+import YAML from 'yaml'
+
+class YAMLFile {
+  constructor(filename) {
+    this.adapter = new TextFile(filename)
+  }
+
+  async read() {
+    const data = await this.adapter.read()
+    if (data === null) {
+      return null
+    } else {
+      return YAML.parse(data)
+    }
+  }
+
+  write(obj) {
+    return this.adapter.write(YAML.stringify(obj))
+  }
+}
+
+const adapter = new YAMLFile('file.yaml')
+const db = new Low(adapter)
+```
+
+## Limits
+
+Lowdb doesn't support Node's cluster module.
+
+If you have large JavaScript objects (`~10-100MB`) you may hit some performance issues. This is because whenever you call `db.write`, the whole `db.data` is serialized using `JSON.stringify` and written to storage.
+
+Depending on your use case, this can be fine or not. It can be mitigated by doing batch operations and calling `db.write` only when you need it.
+
+If you plan to scale, it's highly recommended to use databases like PostgreSQL or MongoDB instead.

25_02_24/node_modules/lowdb/lib/adapters/Memory.d.ts

@@ -0,0 +1,11 @@
+import { Adapter, SyncAdapter } from '../core/Low.js';
+export declare class Memory<T> implements Adapter<T> {
+    #private;
+    read(): Promise<T | null>;
+    write(obj: T): Promise<void>;
+}
+export declare class MemorySync<T> implements SyncAdapter<T> {
+    #private;
+    read(): T | null;
+    write(obj: T): void;
+}

25_02_24/node_modules/lowdb/lib/adapters/Memory.js

@@ -0,0 +1,19 @@
+export class Memory {
+    #data = null;
+    read() {
+        return Promise.resolve(this.#data);
+    }
+    write(obj) {
+        this.#data = obj;
+        return Promise.resolve();
+    }
+}
+export class MemorySync {
+    #data = null;
+    read() {
+        return this.#data || null;
+    }
+    write(obj) {
+        this.#data = obj;
+    }
+}

25_02_24/node_modules/lowdb/lib/adapters/browser/LocalStorage.d.ts

@@ -0,0 +1,4 @@
+import { WebStorage } from './WebStorage.js';
+export declare class LocalStorage<T> extends WebStorage<T> {
+    constructor(key: string);
+}

25_02_24/node_modules/lowdb/lib/adapters/browser/LocalStorage.js

@@ -0,0 +1,6 @@
+import { WebStorage } from './WebStorage.js';
+export class LocalStorage extends WebStorage {
+    constructor(key) {
+        super(key, localStorage);
+    }
+}

25_02_24/node_modules/lowdb/lib/adapters/browser/SessionStorage.d.ts

@@ -0,0 +1,4 @@
+import { WebStorage } from './WebStorage.js';
+export declare class SessionStorage<T> extends WebStorage<T> {
+    constructor(key: string);
+}

25_02_24/node_modules/lowdb/lib/adapters/browser/SessionStorage.js

@@ -0,0 +1,6 @@
+import { WebStorage } from './WebStorage.js';
+export class SessionStorage extends WebStorage {
+    constructor(key) {
+        super(key, sessionStorage);
+    }
+}

25_02_24/node_modules/lowdb/lib/adapters/browser/WebStorage.d.ts

@@ -0,0 +1,7 @@
+import { SyncAdapter } from '../../core/Low.js';
+export declare class WebStorage<T> implements SyncAdapter<T> {
+    #private;
+    constructor(key: string, storage: Storage);
+    read(): T | null;
+    write(obj: T): void;
+}

25_02_24/node_modules/lowdb/lib/adapters/browser/WebStorage.js

@@ -0,0 +1,18 @@
+export class WebStorage {
+    #key;
+    #storage;
+    constructor(key, storage) {
+        this.#key = key;
+        this.#storage = storage;
+    }
+    read() {
+        const value = this.#storage.getItem(this.#key);
+        if (value === null) {
+            return null;
+        }
+        return JSON.parse(value);
+    }
+    write(obj) {
+        this.#storage.setItem(this.#key, JSON.stringify(obj));
+    }
+}

25_02_24/node_modules/lowdb/lib/adapters/node/DataFile.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PathLike } from 'fs';
+import { Adapter, SyncAdapter } from '../../core/Low.js';
+export declare class DataFile<T> implements Adapter<T> {
+    #private;
+    constructor(filename: PathLike, { parse, stringify, }: {
+        parse: (str: string) => T;
+        stringify: (data: T) => string;
+    });
+    read(): Promise<T | null>;
+    write(obj: T): Promise<void>;
+}
+export declare class DataFileSync<T> implements SyncAdapter<T> {
+    #private;
+    constructor(filename: PathLike, { parse, stringify, }: {
+        parse: (str: string) => T;
+        stringify: (data: T) => string;
+    });
+    read(): T | null;
+    write(obj: T): void;
+}

25_02_24/node_modules/lowdb/lib/adapters/node/DataFile.js

@@ -0,0 +1,45 @@
+import { TextFile, TextFileSync } from './TextFile.js';
+export class DataFile {
+    #adapter;
+    #parse;
+    #stringify;
+    constructor(filename, { parse, stringify, }) {
+        this.#adapter = new TextFile(filename);
+        this.#parse = parse;
+        this.#stringify = stringify;
+    }
+    async read() {
+        const data = await this.#adapter.read();
+        if (data === null) {
+            return null;
+        }
+        else {
+            return this.#parse(data);
+        }
+    }
+    write(obj) {
+        return this.#adapter.write(this.#stringify(obj));
+    }
+}
+export class DataFileSync {
+    #adapter;
+    #parse;
+    #stringify;
+    constructor(filename, { parse, stringify, }) {
+        this.#adapter = new TextFileSync(filename);
+        this.#parse = parse;
+        this.#stringify = stringify;
+    }
+    read() {
+        const data = this.#adapter.read();
+        if (data === null) {
+            return null;
+        }
+        else {
+            return this.#parse(data);
+        }
+    }
+    write(obj) {
+        this.#adapter.write(this.#stringify(obj));
+    }
+}

25_02_24/node_modules/lowdb/lib/adapters/node/JSONFile.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PathLike } from 'fs';
+import { DataFile, DataFileSync } from './DataFile.js';
+export declare class JSONFile<T> extends DataFile<T> {
+    constructor(filename: PathLike);
+}
+export declare class JSONFileSync<T> extends DataFileSync<T> {
+    constructor(filename: PathLike);
+}

25_02_24/node_modules/lowdb/lib/adapters/node/JSONFile.js

@@ -0,0 +1,17 @@
+import { DataFile, DataFileSync } from './DataFile.js';
+export class JSONFile extends DataFile {
+    constructor(filename) {
+        super(filename, {
+            parse: JSON.parse,
+            stringify: (data) => JSON.stringify(data, null, 2),
+        });
+    }
+}
+export class JSONFileSync extends DataFileSync {
+    constructor(filename) {
+        super(filename, {
+            parse: JSON.parse,
+            stringify: (data) => JSON.stringify(data, null, 2),
+        });
+    }
+}

25_02_24/node_modules/lowdb/lib/adapters/node/TextFile.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PathLike } from 'node:fs';
+import { Adapter, SyncAdapter } from '../../core/Low.js';
+export declare class TextFile implements Adapter<string> {
+    #private;
+    constructor(filename: PathLike);
+    read(): Promise<string | null>;
+    write(str: string): Promise<void>;
+}
+export declare class TextFileSync implements SyncAdapter<string> {
+    #private;
+    constructor(filename: PathLike);
+    read(): string | null;
+    write(str: string): void;
+}

25_02_24/node_modules/lowdb/lib/adapters/node/TextFile.js

@@ -0,0 +1,54 @@
+import { readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Writer } from 'steno';
+export class TextFile {
+    #filename;
+    #writer;
+    constructor(filename) {
+        this.#filename = filename;
+        this.#writer = new Writer(filename);
+    }
+    async read() {
+        let data;
+        try {
+            data = await readFile(this.#filename, 'utf-8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                return null;
+            }
+            throw e;
+        }
+        return data;
+    }
+    write(str) {
+        return this.#writer.write(str);
+    }
+}
+export class TextFileSync {
+    #tempFilename;
+    #filename;
+    constructor(filename) {
+        this.#filename = filename;
+        const f = filename.toString();
+        this.#tempFilename = path.join(path.dirname(f), `.${path.basename(f)}.tmp`);
+    }
+    read() {
+        let data;
+        try {
+            data = readFileSync(this.#filename, 'utf-8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                return null;
+            }
+            throw e;
+        }
+        return data;
+    }
+    write(str) {
+        writeFileSync(this.#tempFilename, str);
+        renameSync(this.#tempFilename, this.#filename);
+    }
+}

25_02_24/node_modules/lowdb/lib/browser.d.ts

@@ -0,0 +1,3 @@
+export * from './adapters/browser/LocalStorage.js';
+export * from './adapters/browser/SessionStorage.js';
+export * from './presets/browser.js';

25_02_24/node_modules/lowdb/lib/browser.js

@@ -0,0 +1,3 @@
+export * from './adapters/browser/LocalStorage.js';
+export * from './adapters/browser/SessionStorage.js';
+export * from './presets/browser.js';

25_02_24/node_modules/lowdb/lib/core/Low.d.ts

@@ -0,0 +1,24 @@
+export interface Adapter<T> {
+    read: () => Promise<T | null>;
+    write: (data: T) => Promise<void>;
+}
+export interface SyncAdapter<T> {
+    read: () => T | null;
+    write: (data: T) => void;
+}
+export declare class Low<T = unknown> {
+    adapter: Adapter<T>;
+    data: T;
+    constructor(adapter: Adapter<T>, defaultData: T);
+    read(): Promise<void>;
+    write(): Promise<void>;
+    update(fn: (data: T) => unknown): Promise<void>;
+}
+export declare class LowSync<T = unknown> {
+    adapter: SyncAdapter<T>;
+    data: T;
+    constructor(adapter: SyncAdapter<T>, defaultData: T);
+    read(): void;
+    write(): void;
+    update(fn: (data: T) => unknown): void;
+}

25_02_24/node_modules/lowdb/lib/core/Low.js

@@ -0,0 +1,50 @@
+function checkArgs(adapter, defaultData) {
+    if (adapter === undefined)
+        throw new Error('lowdb: missing adapter');
+    if (defaultData === undefined)
+        throw new Error('lowdb: missing default data');
+}
+export class Low {
+    adapter;
+    data;
+    constructor(adapter, defaultData) {
+        checkArgs(adapter, defaultData);
+        this.adapter = adapter;
+        this.data = defaultData;
+    }
+    async read() {
+        const data = await this.adapter.read();
+        if (data)
+            this.data = data;
+    }
+    async write() {
+        if (this.data)
+            await this.adapter.write(this.data);
+    }
+    async update(fn) {
+        fn(this.data);
+        await this.write();
+    }
+}
+export class LowSync {
+    adapter;
+    data;
+    constructor(adapter, defaultData) {
+        checkArgs(adapter, defaultData);
+        this.adapter = adapter;
+        this.data = defaultData;
+    }
+    read() {
+        const data = this.adapter.read();
+        if (data)
+            this.data = data;
+    }
+    write() {
+        if (this.data)
+            this.adapter.write(this.data);
+    }
+    update(fn) {
+        fn(this.data);
+        this.write();
+    }
+}

25_02_24/node_modules/lowdb/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './adapters/Memory.js';
+export * from './core/Low.js';

25_02_24/node_modules/lowdb/lib/index.js

@@ -0,0 +1,2 @@
+export * from './adapters/Memory.js';
+export * from './core/Low.js';

25_02_24/node_modules/lowdb/lib/node.d.ts

@@ -0,0 +1,4 @@
+export * from './adapters/node/DataFile.js';
+export * from './adapters/node/JSONFile.js';
+export * from './adapters/node/TextFile.js';
+export * from './presets/node.js';

25_02_24/node_modules/lowdb/lib/node.js

@@ -0,0 +1,4 @@
+export * from './adapters/node/DataFile.js';
+export * from './adapters/node/JSONFile.js';
+export * from './adapters/node/TextFile.js';
+export * from './presets/node.js';

25_02_24/node_modules/lowdb/lib/presets/browser.d.ts

@@ -0,0 +1,3 @@
+import { LowSync } from '../index.js';
+export declare function LocalStoragePreset<Data>(key: string, defaultData: Data): LowSync<Data>;
+export declare function SessionStoragePreset<Data>(key: string, defaultData: Data): LowSync<Data>;

25_02_24/node_modules/lowdb/lib/presets/browser.js

@@ -0,0 +1,15 @@
+import { LocalStorage } from '../adapters/browser/LocalStorage.js';
+import { SessionStorage } from '../adapters/browser/SessionStorage.js';
+import { LowSync } from '../index.js';
+export function LocalStoragePreset(key, defaultData) {
+    const adapter = new LocalStorage(key);
+    const db = new LowSync(adapter, defaultData);
+    db.read();
+    return db;
+}
+export function SessionStoragePreset(key, defaultData) {
+    const adapter = new SessionStorage(key);
+    const db = new LowSync(adapter, defaultData);
+    db.read();
+    return db;
+}

25_02_24/node_modules/lowdb/lib/presets/node.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PathLike } from 'node:fs';
+import { Low, LowSync } from '../core/Low.js';
+export declare function JSONFilePreset<Data>(filename: PathLike, defaultData: Data): Promise<Low<Data>>;
+export declare function JSONFileSyncPreset<Data>(filename: PathLike, defaultData: Data): LowSync<Data>;

25_02_24/node_modules/lowdb/lib/presets/node.js

@@ -0,0 +1,19 @@
+import { Memory, MemorySync } from '../adapters/Memory.js';
+import { JSONFile, JSONFileSync } from '../adapters/node/JSONFile.js';
+import { Low, LowSync } from '../core/Low.js';
+export async function JSONFilePreset(filename, defaultData) {
+    const adapter = process.env.NODE_ENV === 'test'
+        ? new Memory()
+        : new JSONFile(filename);
+    const db = new Low(adapter, defaultData);
+    await db.read();
+    return db;
+}
+export function JSONFileSyncPreset(filename, defaultData) {
+    const adapter = process.env.NODE_ENV === 'test'
+        ? new MemorySync()
+        : new JSONFileSync(filename);
+    const db = new LowSync(adapter, defaultData);
+    db.read();
+    return db;
+}

25_02_24/node_modules/lowdb/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "lowdb",
+  "version": "7.0.1",
+  "description": "Tiny local JSON database for Node, Electron and the browser",
+  "keywords": [
+    "database",
+    "db",
+    "electron",
+    "embed",
+    "embedded",
+    "flat",
+    "JSON",
+    "local",
+    "localStorage",
+    "sessionStorage",
+    "browser",
+    "esm"
+  ],
+  "homepage": "https://github.com/typicode/lowdb#readme",
+  "bugs": {
+    "url": "https://github.com/typicode/lowdb/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/typicode/lowdb.git"
+  },
+  "funding": "https://github.com/sponsors/typicode",
+  "license": "MIT",
+  "author": "Typicode <typicode@gmail.com>",
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js",
+    "./node": "./lib/node.js",
+    "./browser": "./lib/browser.js"
+  },
+  "types": "./lib",
+  "typesVersions": {
+    "*": {
+      "node": [
+        "lib/node.d.ts"
+      ],
+      "browser": [
+        "lib/browser.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib",
+    "!lib/examples/**/*",
+    "!lib/**/*.test.*"
+  ],
+  "scripts": {
+    "test": "node --import tsx/esm --test src/**/*.test.ts src/**/**/*.test.ts",
+    "lint": "eslint src --ext .ts --ignore-path .gitignore",
+    "build": "del-cli lib && tsc",
+    "prepublishOnly": "npm run build",
+    "postversion": "git push --follow-tags && npm publish",
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "steno": "^4.0.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^18.4.3",
+    "@commitlint/config-conventional": "^18.4.3",
+    "@commitlint/prompt-cli": "^18.4.3",
+    "@sindresorhus/tsconfig": "^5.0.0",
+    "@types/express": "^4.17.21",
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^20.10.5",
+    "@typicode/eslint-config": "^1.2.0",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.56.0",
+    "express-async-handler": "^1.2.0",
+    "husky": "^8.0.3",
+    "lodash": "^4.17.21",
+    "tempy": "^3.1.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}