rockbed 0.1.0

package/dist/index.js

@@ -0,0 +1,989 @@
+// src/assert/assert.ts
+function abort(reason) {
+  throw new Error(`lvAssert(${reason})`);
+}
+function lvAssert(expr, reason) {
+  if (!expr) {
+    abort(reason ?? "#expr is false");
+  }
+}
+function lvAssertNotHere(reason) {
+  abort(reason ?? "unreachable code flow");
+}
+function lvAssertNever(member, message = "Illegal value:") {
+  abort(`${message}: ${member}`);
+}
+function lvAssertNotNil(val, reason) {
+  if (val === null || val === void 0) {
+    abort(reason ?? "#val is nil");
+  }
+}
+
+// src/error/error-base.ts
+var ILvErrorRef = /* @__PURE__ */ Symbol.for("rockbed.ILvErrorRef");
+var ILvRealErrorRef = /* @__PURE__ */ Symbol.for("rockbed.ILvRealErrorRef");
+var ILvValueRef = /* @__PURE__ */ Symbol.for("rockbed.ILvValueRef");
+var ILvErrorOr = /* @__PURE__ */ Symbol.for("rockbed.ILvErrorOr");
+
+// src/error/error-t.ts
+var lvErrorRefSymbol = /* @__PURE__ */ Symbol("lvErrorRef");
+function makeOk() {
+  return {
+    ok: true,
+    value: null,
+    pair() {
+      return [null, null];
+    },
+    code: 0,
+    msg: "",
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+}
+function makeOkWith(value) {
+  return {
+    ok: true,
+    value,
+    pair() {
+      return [null, value];
+    },
+    code: 0,
+    msg: "",
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+}
+function printCause(cause) {
+  if (cause === void 0) {
+    return "";
+  } else if (cause instanceof Error) {
+    return `
+caused by [jsError]${cause.name}-${cause.message}`;
+  } else {
+    return `
+caused by [${cause.code}]${cause.msg}${cause.ok ? "" : printCause(cause.cause)}`;
+  }
+}
+function internalMakeError(code, msg, cause, errorInfo) {
+  const errorRef = {
+    ok: false,
+    code,
+    msg,
+    cause,
+    errorInfo,
+    toString() {
+      return `[${code}]${msg}.${cause ? printCause(cause) : ""}`;
+    },
+    pair() {
+      return [errorRef, null];
+    },
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+  return errorRef;
+}
+function makeError(code, msg, errorInfo) {
+  return internalMakeError(code, msg, void 0, errorInfo);
+}
+function makeErrorBy(code, msg, cause, errorInfo) {
+  return internalMakeError(code, msg, cause, errorInfo);
+}
+function isLvErrorRef(val) {
+  return typeof val === "object" && val !== null && lvErrorRefSymbol in val;
+}
+
+// src/error/error-const.ts
+function lvErrorConst(code, msg) {
+  return (rewrite) => {
+    if (!rewrite) {
+      return makeError(code, msg);
+    }
+    if (typeof rewrite === "string") {
+      return makeError(code, rewrite);
+    }
+    return makeErrorBy(code, rewrite.message, rewrite);
+  };
+}
+
+// src/error/error-code.ts
+var GenericError = /* @__PURE__ */ ((GenericError2) => {
+  GenericError2[GenericError2["Ok"] = 0] = "Ok";
+  GenericError2[GenericError2["Cancelled"] = 1] = "Cancelled";
+  GenericError2[GenericError2["TimedOut"] = 2] = "TimedOut";
+  GenericError2[GenericError2["PermissionDenied"] = 3] = "PermissionDenied";
+  GenericError2[GenericError2["AlreadyExists"] = 4] = "AlreadyExists";
+  GenericError2[GenericError2["NotSupported"] = 5] = "NotSupported";
+  GenericError2[GenericError2["ResourceUnavailable"] = 6] = "ResourceUnavailable";
+  GenericError2[GenericError2["OutOfRange"] = 7] = "OutOfRange";
+  GenericError2[GenericError2["InvalidArgument"] = 8] = "InvalidArgument";
+  GenericError2[GenericError2["NetworkFailed"] = 9] = "NetworkFailed";
+  GenericError2[GenericError2["Interrupted"] = 10] = "Interrupted";
+  GenericError2[GenericError2["ResultNil"] = 11] = "ResultNil";
+  return GenericError2;
+})(GenericError || {});
+var cancelledError = lvErrorConst(1 /* Cancelled */, "operation(s) cancelled.");
+var timeoutError = lvErrorConst(2 /* TimedOut */, "operation(s) timed out.");
+var permissionDeniedError = lvErrorConst(
+  3 /* PermissionDenied */,
+  "permission denied."
+);
+var alreadyExistsError = lvErrorConst(4 /* AlreadyExists */, "already exists.");
+var notSupportedError = lvErrorConst(
+  5 /* NotSupported */,
+  "operation(s) not supported."
+);
+var resourceUnavailableError = lvErrorConst(
+  6 /* ResourceUnavailable */,
+  "resource is unavailable."
+);
+var outOfRangeError = lvErrorConst(7 /* OutOfRange */, "out of range.");
+var invalidArgumentError = lvErrorConst(
+  8 /* InvalidArgument */,
+  "invalid arguments."
+);
+var networkFailedError = lvErrorConst(9 /* NetworkFailed */, "network failed.");
+var interruptedError = lvErrorConst(10 /* Interrupted */, "interrupted.");
+var resultNilError = lvErrorConst(11 /* ResultNil */, "result is nil.");
+
+// src/dispose/dispose-base.ts
+var EmptyDispose = Object.freeze({ dispose() {
+} });
+
+// src/dispose/logger.ts
+var disposableLogger = null;
+function setDisposableLogger(logger) {
+  disposableLogger = logger;
+}
+function makeDefaultLogger() {
+  return new class {
+    _dep = [];
+    branch(from, to) {
+      this._dep.push([from, to]);
+    }
+    end() {
+    }
+  }();
+}
+function BRANCH_DISPOSE(from, to) {
+  disposableLogger?.branch(from, to);
+}
+function disposeWithLog(x, logger = makeDefaultLogger()) {
+  setDisposableLogger(logger);
+  x.dispose();
+  logger.end();
+  setDisposableLogger(null);
+}
+
+// src/dispose/disposable-store.ts
+var DisposableStore = class _DisposableStore {
+  static DISABLE_DISPOSED_WARNING = false;
+  _toDispose = /* @__PURE__ */ new Set();
+  _isDisposed = false;
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  dispose() {
+    if (this._isDisposed) {
+      console.warn(new Error("DisposableStore has disposed.").stack);
+      return;
+    }
+    this._isDisposed = true;
+    this.clear();
+  }
+  clear() {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+    for (const disposable of this._toDispose) {
+      BRANCH_DISPOSE(this.constructor.name, disposable.constructor.name);
+    }
+    try {
+      for (const disposable of this._toDispose) {
+        disposable.dispose();
+      }
+    } finally {
+      this._toDispose.clear();
+    }
+  }
+  add(o) {
+    if (!o) {
+      return o;
+    }
+    if (o === this) {
+      throw new Error("Cannot register a disposable on itself.");
+    }
+    if (this._isDisposed) {
+      if (!_DisposableStore.DISABLE_DISPOSED_WARNING) {
+        console.warn(
+          new Error(
+            "Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!"
+          ).stack
+        );
+      }
+    } else {
+      this._toDispose.add(o);
+    }
+    return o;
+  }
+};
+
+// src/dispose/disposable-t.ts
+var Disposable = class {
+  _store = new DisposableStore();
+  // 销毁该节点和所有的子节点
+  dispose() {
+    BRANCH_DISPOSE(this.constructor.name, this._store.constructor.name);
+    this._store.dispose();
+  }
+  // 挂载子节点
+  _register(o) {
+    if (o === this) {
+      throw new Error("Cannot register a disposable on itself!");
+    }
+    return this._store.add(o);
+  }
+};
+var MutableDisposable = class {
+  _value;
+  _isDisposed = false;
+  constructor(value) {
+    this.value = value;
+  }
+  get value() {
+    return this._isDisposed ? void 0 : this._value;
+  }
+  set value(value) {
+    if (this._isDisposed || value === this._value) {
+      return;
+    }
+    this._value?.dispose();
+    this._value = value;
+  }
+  clear() {
+    this.value = void 0;
+  }
+  dispose() {
+    this._isDisposed = true;
+    this._value?.dispose();
+    this._value = void 0;
+  }
+  release() {
+    const oldValue = this._value;
+    this._value = void 0;
+    return oldValue;
+  }
+};
+var SafeDisposable = class {
+  _value = null;
+  constructor(value) {
+    this._value = value;
+  }
+  isEmpty() {
+    return this._value === null;
+  }
+  dispose() {
+    if (!this._value) {
+      return;
+    }
+    this._value.dispose();
+    this._value = null;
+  }
+};
+
+// src/dispose/disposable-utils.ts
+function makeSafeDisposable(fn) {
+  const disposable = new SafeDisposable({
+    dispose: fn
+  });
+  return disposable;
+}
+function makeEmptyDisposable() {
+  return EmptyDispose;
+}
+
+// src/async/promise.ts
+var shortcutCancellationEvent = (callback, context) => {
+  const handle = setTimeout(callback.bind(context), 0);
+  return makeSafeDisposable(() => clearTimeout(handle));
+};
+var MutableToken = class {
+  _isCancelled = false;
+  _reason;
+  _listeners = /* @__PURE__ */ new Set();
+  get isCancellationRequested() {
+    return this._isCancelled;
+  }
+  get reason() {
+    return this._reason;
+  }
+  onCancellationRequested(listener, thisArgs) {
+    if (this._isCancelled) {
+      return shortcutCancellationEvent(listener, thisArgs);
+    }
+    const wrappedListener = listener.bind(thisArgs);
+    this._listeners.add(wrappedListener);
+    return makeSafeDisposable(() => {
+      this._listeners.delete(wrappedListener);
+    });
+  }
+  cancel(reason) {
+    if (this._isCancelled) {
+      return;
+    }
+    this._reason = reason;
+    this._isCancelled = true;
+    for (const listener of this._listeners) {
+      listener();
+    }
+    this._listeners.clear();
+  }
+  dispose() {
+    this._listeners.clear();
+  }
+};
+var CancellationToken = class {
+  static None = Object.freeze({
+    isCancellationRequested: false,
+    onCancellationRequested: () => EmptyDispose
+  });
+  static Cancelled = Object.freeze({
+    isCancellationRequested: true,
+    onCancellationRequested: shortcutCancellationEvent
+  });
+  static Make(reason) {
+    return Object.freeze({
+      isCancellationRequested: true,
+      onCancellationRequested: shortcutCancellationEvent,
+      reason
+    });
+  }
+};
+var CancellationTokenSource = class {
+  _token;
+  _abortController;
+  get token() {
+    if (!this._token) {
+      this._token = new MutableToken();
+    }
+    return this._token;
+  }
+  get signal() {
+    if (!this._abortController) {
+      this._abortController = new AbortController();
+    }
+    if (this._token?.isCancellationRequested) {
+      this._abortController.abort(this._token.reason);
+    }
+    return this._abortController.signal;
+  }
+  cancel(reason) {
+    if (!this._token) {
+      this._token = reason === void 0 ? CancellationToken.Cancelled : CancellationToken.Make(reason);
+    } else if (this._token instanceof MutableToken) {
+      this._token.cancel(reason);
+    }
+    this._abortController?.abort(reason);
+  }
+  dispose(cancel = false) {
+    if (cancel) {
+      this.cancel();
+    }
+    if (!this._token) {
+      this._token = CancellationToken.None;
+    } else if (this._token instanceof MutableToken) {
+      this._token.dispose();
+    }
+  }
+};
+function makeCancelablePromise(callback) {
+  const source = new CancellationTokenSource();
+  const thenable = callback(source.token);
+  const promise = new Promise((resolve, reject) => {
+    const subscription = source.token.onCancellationRequested(() => {
+      subscription.dispose();
+      source.dispose();
+      resolve(cancelledError());
+    });
+    Promise.resolve(thenable).then(
+      (value) => {
+        subscription.dispose();
+        source.dispose();
+        if (isLvErrorRef(value)) {
+          resolve(value);
+        } else {
+          resolve(makeOkWith(value));
+        }
+      },
+      (err) => {
+        subscription.dispose();
+        source.dispose();
+        reject(err);
+      }
+    );
+  });
+  return new class {
+    cancel() {
+      source.cancel();
+    }
+    then(resolve, reject) {
+      return promise.then(resolve, reject);
+    }
+    catch(reject) {
+      return this.then(void 0, reject);
+    }
+    finally(onfinally) {
+      return promise.finally(onfinally);
+    }
+  }();
+}
+function parallelPromise(promiseList) {
+  if (promiseList.length === 0) {
+    return Promise.resolve(makeOk());
+  }
+  let todo = promiseList.length;
+  const finish = () => {
+    todo = -1;
+    for (const promise of promiseList) {
+      promise.cancel?.();
+    }
+  };
+  return new Promise((resolve, reject) => {
+    for (const promise of promiseList) {
+      promise.then((res) => {
+        if (isLvErrorRef(res) && !res.ok) {
+          finish();
+          resolve(res);
+          return;
+        }
+        todo--;
+        if (todo === 0) {
+          resolve(makeOk());
+        }
+      }).catch((err) => {
+        finish();
+        reject(err);
+      });
+    }
+  });
+}
+function makePromiseWithTimeout(callback, timeout, defaultValue) {
+  const cancellable = makeCancelablePromise(callback);
+  const timer = setTimeout(() => {
+    cancellable.cancel();
+  }, timeout);
+  return cancellable.then((res) => {
+    clearTimeout(timer);
+    if (res.ok) {
+      return res;
+    }
+    if (res.code === 1 /* Cancelled */) {
+      if (defaultValue !== void 0) {
+        return makeOkWith(defaultValue);
+      }
+      return timeoutError();
+    } else {
+      return res;
+    }
+  });
+}
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+
+// src/async/wait.ts
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/async/barrier.ts
+var Barrier = class {
+  _isOpen;
+  _promise;
+  _completePromise;
+  constructor() {
+    this._isOpen = false;
+    this._promise = new Promise((c, e) => {
+      this._completePromise = c;
+    });
+  }
+  isOpen() {
+    return this._isOpen;
+  }
+  open() {
+    this._isOpen = true;
+    this._completePromise(true);
+  }
+  wait() {
+    return this._promise;
+  }
+};
+function makeBarrierByPromise(promise, openWhenReject = false) {
+  const barrier = new Barrier();
+  promise.then(() => barrier.open());
+  if (openWhenReject) {
+    promise.catch((err) => {
+      barrier.open();
+      throw err;
+    });
+  }
+  return barrier;
+}
+
+// src/event/emitter.ts
+function asyncUnexpectedErrorHandler(e) {
+  setTimeout(() => {
+    throw e;
+  }, 0);
+}
+function syncUnexpectedError(e) {
+  throw e;
+}
+function ignoreUnexpectedError(_e) {
+}
+var Listener = class {
+  _callback;
+  _callbackThis;
+  constructor(callback, callbackThis) {
+    this._callback = callback;
+    this._callbackThis = callbackThis;
+  }
+  invoke(...args) {
+    this._callback.call(this._callbackThis, ...args);
+  }
+};
+var EventDeliveryQueueElement = class {
+  emitter;
+  listener;
+  event;
+  constructor(emitter, listener, event) {
+    this.emitter = emitter;
+    this.listener = listener;
+    this.event = event;
+  }
+};
+var EventDeliveryQueue = class {
+  constructor(_onListenerError = asyncUnexpectedErrorHandler) {
+    this._onListenerError = _onListenerError;
+  }
+  _onListenerError;
+  _queue = [];
+  get size() {
+    return this._queue.length;
+  }
+  push(emitter, listener, event) {
+    this._queue.push(new EventDeliveryQueueElement(emitter, listener, event));
+  }
+  clear(emitter) {
+    this._queue = this._queue.filter((element) => element.emitter !== emitter);
+  }
+  deliver() {
+    while (this._queue.length > 0) {
+      const element = this._queue.shift();
+      try {
+        element.listener.invoke(...element.event);
+      } catch (e) {
+        this._onListenerError(e);
+      }
+    }
+  }
+};
+var Emitter = class {
+  _listeners;
+  _options;
+  _disposed = false;
+  _event;
+  _deliveryQueue;
+  constructor(options) {
+    this._options = options;
+  }
+  get event() {
+    if (this._event) {
+      return this._event;
+    }
+    this._event = (callback, thisArgs) => {
+      if (!this._listeners) {
+        this._listeners = /* @__PURE__ */ new Set();
+      }
+      const listener = new Listener(callback, thisArgs);
+      this._listeners.add(listener);
+      if (this._options?.onAddListener) {
+        this._options.onAddListener(this, callback, thisArgs);
+      }
+      const result = () => {
+        if (!this._disposed) {
+          this._listeners?.delete(listener);
+          if (this._options?.onRemoveListener) {
+            this._options.onRemoveListener(this, callback, thisArgs);
+          }
+        }
+      };
+      return makeSafeDisposable(result);
+    };
+    return this._event;
+  }
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+    this._disposed = true;
+    this._listeners?.clear();
+    this._deliveryQueue?.clear(this);
+  }
+  fire(...event) {
+    if (!this._listeners) {
+      return;
+    }
+    this._deliveryQueue ??= new EventDeliveryQueue(this._options?.onListenerError);
+    for (const listener of this._listeners) {
+      this._deliveryQueue.push(this, listener, event);
+    }
+    this._deliveryQueue.deliver();
+  }
+};
+function listenOnce(event) {
+  return (listener, thisArgs = null) => {
+    let didFire = false;
+    let result = void 0;
+    result = event((...args) => {
+      if (didFire) {
+        return;
+      }
+      if (result) {
+        result.dispose();
+      } else {
+        didFire = true;
+      }
+      return listener.call(thisArgs, ...args);
+    }, null);
+    if (didFire) {
+      result.dispose();
+    }
+    return result;
+  };
+}
+
+// src/json/json.ts
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return {};
+  }
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    return "{}";
+  }
+}
+
+// src/lock/capability.ts
+var Capability = class {
+  onUnlocked;
+  _onUnlocked = new Emitter();
+  _status = 0 /* Unlocked */;
+  constructor() {
+    this.onUnlocked = this._onUnlocked.event;
+  }
+  get status() {
+    return this._status;
+  }
+  acquire() {
+    lvAssert(this._status === 0 /* Unlocked */);
+    this._status = 1 /* Locked */;
+  }
+  release() {
+    lvAssert(this._status === 1 /* Locked */);
+    this._status = 0 /* Unlocked */;
+    this._onUnlocked.fire();
+  }
+};
+var SharedCapability = class {
+  onUnlocked;
+  _onUnlocked = new Emitter();
+  _status = 0 /* Unlocked */;
+  _counter = 0;
+  constructor() {
+    this.onUnlocked = this._onUnlocked.event;
+  }
+  get status() {
+    return this._status;
+  }
+  get counter() {
+    return this._counter;
+  }
+  acquire() {
+    if (this._status === 0 /* Unlocked */) {
+      this._status = 1 /* Locked */;
+    }
+    this._counter++;
+  }
+  release() {
+    lvAssert(this._counter > 0);
+    this._counter--;
+    if (this._counter === 0) {
+      this._status = 0 /* Unlocked */;
+      this._onUnlocked.fire();
+    }
+  }
+};
+
+// src/lock/semaphore.ts
+var Semaphore = class {
+  onActive;
+  _onActive = new Emitter();
+  constructor() {
+    this.onActive = this._onActive.event;
+  }
+  notify() {
+    this._onActive.fire();
+  }
+};
+
+// src/lock/shared-mutex.ts
+var SharedMutex = class {
+  // 在第一道门外等待的写者
+  _waitingWriters = [];
+  // 已经通过了第一道门的写者
+  // 如果在第二道门外等待，状态为sharedLocked
+  // 如果已经进入到第二道门内拿到了锁，状态为locked
+  _writer;
+  // 在第一道门外等待的读者
+  _waitingReader;
+  // 拿到锁的读者
+  _reader;
+  /**
+   * 是否被锁住
+   */
+  isLocked() {
+    return Boolean(this._writer) || this._readerCount !== 0;
+  }
+  /**
+   * 等待并获取写锁
+   */
+  lock() {
+    return new Promise((resolve) => {
+      if (this._writer) {
+        const token = new Semaphore();
+        this._waitingWriters.push(token);
+        token.onActive(() => {
+          this._writerEnterGate1(resolve);
+        });
+      } else {
+        this._writerEnterGate1(resolve);
+      }
+    });
+  }
+  /**
+   * 尝试获取写锁，立刻返回结果
+   */
+  tryLock() {
+    if (this._writer || this._readerCount > 0) {
+      return false;
+    }
+    this.lock();
+    return true;
+  }
+  /**
+   * 解除写锁
+   */
+  unLock() {
+    lvAssertNotNil(this._writer);
+    this._writer.release();
+  }
+  /**
+   * 解除写锁。`unLock` 的常规拼写别名。
+   */
+  unlock() {
+    this.unLock();
+  }
+  /**
+   * 等待并获取读锁
+   */
+  lockShared() {
+    return new Promise((resolve) => {
+      if (this._writer) {
+        if (!this._waitingReader) {
+          this._waitingReader = new Semaphore();
+        }
+        this._waitingReader.onActive(() => {
+          this._readerEnterGate1(resolve);
+        });
+      } else {
+        this._readerEnterGate1(resolve);
+      }
+    });
+  }
+  /**
+   * 尝试获取读锁，立刻返回结果
+   */
+  tryLockShared() {
+    if (this._writer) {
+      return false;
+    }
+    this.lockShared();
+    return true;
+  }
+  /**
+   * 解除读锁
+   */
+  unLockShared() {
+    lvAssertNotNil(this._reader);
+    if (this._writer) {
+      lvAssert(this._writer.status === 0 /* Unlocked */);
+    }
+    this._reader.release();
+  }
+  /**
+   * 解除读锁。`unLockShared` 的常规拼写别名。
+   */
+  unlockShared() {
+    this.unLockShared();
+  }
+  /**
+   * 获取当前读者数量
+   */
+  get _readerCount() {
+    return this._reader ? this._reader.counter : 0;
+  }
+  /**
+   * 写者进入第一道门
+   */
+  _writerEnterGate1(resolve) {
+    lvAssert(!this._writer);
+    this._writer = new Capability();
+    if (this._readerCount > 0) {
+      listenOnce(this._reader.onUnlocked)(() => {
+        this._writerEnterGate2(resolve);
+      });
+    } else {
+      this._writerEnterGate2(resolve);
+    }
+  }
+  /**
+   * 写者进入第二道门
+   */
+  _writerEnterGate2(resolve) {
+    lvAssertNotNil(this._writer);
+    lvAssert(this._readerCount === 0);
+    this._writer.acquire();
+    listenOnce(this._writer.onUnlocked)(() => {
+      lvAssertNotNil(this._writer);
+      this._writer = void 0;
+      this._moveForward();
+    });
+    resolve();
+  }
+  /**
+   * 读者进入第一道门
+   */
+  _readerEnterGate1(resolve) {
+    lvAssert(!this._writer);
+    this._waitingReader = void 0;
+    if (!this._reader) {
+      this._reader = new SharedCapability();
+      this._reader.acquire();
+      listenOnce(this._reader.onUnlocked)(() => {
+        this._moveForward();
+      });
+    } else {
+      this._reader.acquire();
+    }
+    resolve();
+  }
+  /**
+   * 锁释放时推进流程
+   */
+  _moveForward() {
+    if (this._writer) {
+      return;
+    }
+    if (this._waitingWriters.length > 0) {
+      const semaphore = this._waitingWriters.shift();
+      semaphore.notify();
+      return;
+    }
+    if (this._waitingReader) {
+      this._waitingReader.notify();
+    }
+  }
+};
+
+// src/response/response.ts
+function makeSuccessResponse(data) {
+  return {
+    code: 0,
+    data,
+    msg: "success"
+  };
+}
+function makeErrorResponse(code, msg) {
+  return {
+    code,
+    msg
+  };
+}
+export {
+  Barrier,
+  CancellationToken,
+  CancellationTokenSource,
+  Disposable,
+  DisposableStore,
+  Emitter,
+  EmptyDispose,
+  EventDeliveryQueue,
+  GenericError,
+  ILvErrorOr,
+  ILvErrorRef,
+  ILvRealErrorRef,
+  ILvValueRef,
+  MutableDisposable,
+  SafeDisposable,
+  SharedMutex,
+  alreadyExistsError,
+  asyncUnexpectedErrorHandler,
+  cancelledError,
+  defer,
+  disposeWithLog,
+  ignoreUnexpectedError,
+  interruptedError,
+  invalidArgumentError,
+  isLvErrorRef,
+  listenOnce,
+  lvAssert,
+  lvAssertNever,
+  lvAssertNotHere,
+  lvAssertNotNil,
+  lvErrorConst,
+  makeBarrierByPromise,
+  makeCancelablePromise,
+  makeEmptyDisposable,
+  makeError,
+  makeErrorBy,
+  makeErrorResponse,
+  makeOk,
+  makeOkWith,
+  makePromiseWithTimeout,
+  makeSafeDisposable,
+  makeSuccessResponse,
+  networkFailedError,
+  notSupportedError,
+  outOfRangeError,
+  parallelPromise,
+  permissionDeniedError,
+  resourceUnavailableError,
+  resultNilError,
+  safeJsonParse,
+  safeJsonStringify,
+  syncUnexpectedError,
+  timeoutError,
+  wait
+};
+//# sourceMappingURL=index.js.map