remove node_modules and .gitignore them

node_modules/tstl/thread/MutableSingleton.d.ts

@@ -1,105 +0,0 @@
-/**
- * Mutable singleton generator.
- *
- * The `MutableSingleton` is an asynchronous singleton generator class who guarantees the *lazy
- * constructor* to be called *"only one at time"*. The *"only one at time"* would always be
- * kepted, even in the race condition.
- *
- * Create a `MutableSingleton` instance with your custom *lazy constructor* and get the promised
- * value through the {@link MutableSingleton.get}() method. The {@link MutableSingleton.get}()
- * method would construct the return value following below logics:
- *
- *   - At the first time: calls the *lazy constructor* and returns the value.
- *   - After the *lazy construction*: returns the pre-constructed value.
- *   - Race condition:
- *     - simultaneously call happens during the *lazy construction*.
- *     - guarantees the *"only one at time"* through a *mutex*.
- *
- * If you want to reload the promised value, regardless of whether the *lazy construction* has
- * been completed or not, call the {@link MutableSingleton.reload}() method. It would call the
- * *lazy constructor* forcibly, even if the *lany construction* has been completed in sometime.
- *
- * @template T Type of the promised value to be lazy-constructed.
- * @author Jeongho Nam - https://github.com/samchon
- */
-export declare class MutableSingleton<T, Args extends any[] = []> {
-    /**
-     * @hidden
-     */
-    private readonly closure_;
-    /**
-     * @hidden
-     */
-    private readonly mutex_;
-    /**
-     * @hidden
-     */
-    private value_;
-    /**
-     * Initializer Constructor.
-     *
-     * Create a new `Singleton` instance with the *lazy consturctor*.
-     *
-     * @param closure Lazy constructor function returning the promised value.
-     */
-    constructor(closure: (...args: Args) => Promise<T>);
-    /**
-     * Reload value.
-     *
-     * The `MutableSingleton.reload()` method enforces to call the *lazy constructor*, regardless
-     * of whether the *lazy construction* has been completed or not. Therefore, even if the *lazy
-     * construction* has been completed in sometime, the `MutableSingleton.reload()` will call
-     * the *lazy constructor* again.
-     *
-     * @return Re-constructed value.
-     */
-    reload(...args: Args): Promise<T>;
-    /**
-     * Configure value.
-     *
-     * The `MutableSingleton.set()` method enforces the singleton to have a specific value.
-     *
-     * @param value The value to configure
-     */
-    set(value: T): Promise<void>;
-    /**
-     * Clear value.
-     *
-     * The `MutableSingleton.clear()` is a method clearing cached value.
-     *
-     * Therefore, when {@link get} being called, closure of constructor would be reused.
-     */
-    clear(): Promise<void>;
-    /**
-     * Get promised value.
-     *
-     * `MutableSingleton.get()` method returns the *lazy constructed value*. It guarantees the
-     * *lazy constructor* to be called *"only one at time"*. It ensures the *"only one at time"*,
-     * even in the race condition.
-     *
-     * If the promised value is not constructed yet (call this method at the first time), the
-     * *lazy constructor* would be called and returns the promised value. Otherwise, the promised
-     * value has been already constructed by the *lazy constructor* (this method already had been
-     * called), returns the pre-generated value.
-     *
-     * Also, you don't need to worry anything about the race condition, who may be occured by
-     * calling the `MutableSingleton.get()` method simultaneously during the *lazy construction*
-     * is on going. The `MutableSingleton` guarantees the *lazy constructor* to be called
-     * only one at time by using the {@link UniqueLock.lock} on a {@link Mutex}.
-     *
-     * @return The *lazy constructed* value.
-     */
-    get(...args: Args): Promise<T>;
-    /**
-     * Test whether the value has been loaded.
-     *
-     * The `MutableSingleton.is_loaded()` method tests whether the singleton has coompleted to
-     * constructing its value or not. If the singleton value is on the construction by the
-     * {@link MutableSingleton.get} or {@link MutableSingleton.reload} method, the
-     * `MutableSingleton.is_loaded()` would wait returning value until the construction has been
-     * completed.
-     *
-     * @returns Whether loaded or not
-     */
-    is_loaded(): Promise<boolean>;
-}