@zk-tech/bedrock 0.0.1

package/dist/di/index.cjs

@@ -0,0 +1,1965 @@
+'use strict';
+
+var react = require('react');
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/di/base.ts
+var serviceIds = /* @__PURE__ */ new Map();
+var DI_TARGET = "$di$target";
+var DI_DEPENDENCIES = "$di$dependencies";
+function getServiceDependencies(ctor) {
+  return ctor[DI_DEPENDENCIES] || [];
+}
+function setServiceDependency(id, ctor, index) {
+  if (ctor[DI_TARGET] === ctor) {
+    ctor[DI_DEPENDENCIES].push({ id, index });
+  } else {
+    ctor[DI_DEPENDENCIES] = [{ id, index }];
+    ctor[DI_TARGET] = ctor;
+  }
+}
+function createDecorator(serviceId) {
+  if (serviceIds.has(serviceId)) {
+    return serviceIds.get(serviceId);
+  }
+  const id = function(target, key, index) {
+    if (arguments.length !== 3) {
+      throw new Error("@IServiceName-decorator can only be used to decorate a parameter");
+    }
+    setServiceDependency(id, target, index);
+  };
+  id.toString = () => serviceId;
+  serviceIds.set(serviceId, id);
+  return id;
+}
+function refineServiceDecorator(serviceIdentifier) {
+  return serviceIdentifier;
+}
+
+// src/di/descriptor.ts
+var SyncDescriptor = class {
+  constructor(ctor, staticArguments = [], supportsDelayedInstantiation = false) {
+    this.ctor = ctor;
+    this.staticArguments = staticArguments;
+    this.supportsDelayedInstantiation = supportsDelayedInstantiation;
+  }
+};
+
+// src/di/instantiation-service.interface.ts
+var IInstantiationService = createDecorator("instantiation");
+
+// src/_internal/logger.ts
+var Logger = {
+  error(...data) {
+    if (typeof console.error === "function") {
+      console.error(...data);
+    }
+  },
+  info(...data) {
+    if (typeof console.info === "function") {
+      console.info(...data);
+    }
+  },
+  log(...data) {
+    if (typeof console.log === "function") {
+      console.log(...data);
+    }
+  },
+  time(label) {
+    if (typeof console.time === "function") {
+      console.time(label);
+    }
+  },
+  timeEnd(label) {
+    if (typeof console.timeEnd === "function") {
+      console.timeEnd(label);
+    }
+  },
+  timeLog(label, ...data) {
+    if (typeof console.timeLog === "function") {
+      console.timeLog(label, ...data);
+    }
+  },
+  timeStamp(label) {
+    if (typeof console.timeStamp === "function") {
+      console.timeStamp(label);
+    }
+  },
+  trace(...data) {
+    if (typeof console.trace === "function") {
+      console.trace(...data);
+    }
+  },
+  warn(...data) {
+    if (typeof console.warn === "function") {
+      console.warn(...data);
+    }
+  },
+  profile(label) {
+    if (typeof console.profile === "function") {
+      console.profile(label);
+    }
+  },
+  profileEnd(label) {
+    if (typeof console.profileEnd === "function") {
+      console.profileEnd(label);
+    }
+  }
+};
+
+// src/assert/assert.ts
+function abort(reason) {
+  throw new Error(`lvAssert(${reason})`);
+}
+function lvAssert(expr, reason) {
+  if (!expr) {
+    abort(reason ?? "#expr is false");
+  }
+}
+function lvAssertNotNil(val, reason) {
+  if (val === null || val === void 0) {
+    abort(reason ?? "#val is nil");
+  }
+}
+
+// src/dispose/disposable-t.ts
+var SafeDisposable = class {
+  constructor(value) {
+    this._value = value;
+  }
+  get value() {
+    return this._value;
+  }
+  isEmpty() {
+    return this._value === void 0;
+  }
+  dispose() {
+    if (!this._value) {
+      return;
+    }
+    this._value.dispose();
+    this._value = void 0;
+  }
+};
+
+// src/dispose/disposable-utils.ts
+function makeSafeDisposable(fn) {
+  const disposable = new SafeDisposable({
+    dispose: fn
+  });
+  return disposable;
+}
+function isDisposable(thing) {
+  return typeof thing.dispose === "function" && thing.dispose.length === 0;
+}
+
+// src/scheduler/core/task.ts
+var Task = class {
+  constructor(callback, _startTime, _expirationTime) {
+    this._startTime = _startTime;
+    this._expirationTime = _expirationTime;
+    this._sortIndex = -1;
+    this._callback = callback;
+  }
+  getCallback() {
+    return this._callback;
+  }
+  setCallback(callback) {
+    lvAssert(this._callback === void 0, "cant overlay callback.");
+    this._callback = callback;
+  }
+  clearCallback() {
+    this._callback = void 0;
+  }
+  getStartTime() {
+    return this._startTime;
+  }
+  setStartTime(startTime) {
+    this._startTime = startTime;
+  }
+  getExpirationTime() {
+    return this._expirationTime;
+  }
+  setExpirationTime(expirationTime) {
+    this._expirationTime = expirationTime;
+  }
+  setSortIndex(index) {
+    this._sortIndex = index;
+  }
+  getSortIndex() {
+    return this._sortIndex;
+  }
+};
+
+// src/scheduler/core/utils.ts
+var maxSigned31BitInt = 1073741823;
+var IMMEDIATE_PRIORITY_TIMEOUT = -1;
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5e3;
+var LOW_PRIORITY_TIMEOUT = 1e4;
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt;
+function getCurrentTime() {
+  return Date.now();
+}
+function getTimeout(priorityLevel = 2 /* NormalPriority */) {
+  switch (priorityLevel) {
+    case 0 /* ImmediatePriority */:
+      return IMMEDIATE_PRIORITY_TIMEOUT;
+    case 1 /* UserBlockingPriority */:
+      return USER_BLOCKING_PRIORITY_TIMEOUT;
+    case 4 /* IdlePriority */:
+      return IDLE_PRIORITY_TIMEOUT;
+    case 3 /* LowPriority */:
+      return LOW_PRIORITY_TIMEOUT;
+    case 2 /* NormalPriority */:
+    default:
+      return NORMAL_PRIORITY_TIMEOUT;
+  }
+}
+function makeTask(callback, options = {}) {
+  const currentTime = getCurrentTime();
+  const delay = options.delay ?? 0;
+  const timeout = getTimeout(options.priorityLevel);
+  const startTime = delay + currentTime;
+  const expirationTime = startTime + timeout;
+  const newTask = new Task(callback, startTime, expirationTime);
+  return newTask;
+}
+
+// src/scheduler/core/chunk-scheduler.ts
+var ChunkScheduler = class {
+  constructor(_task, _scheduler) {
+    this._task = _task;
+    this._scheduler = _scheduler;
+    this._needContinue = false;
+  }
+  get needContinue() {
+    return this._needContinue;
+  }
+  continueExecute(callback) {
+    this._needContinue = true;
+    this._task.setCallback(callback);
+  }
+  execute(callback, options = {}) {
+    const newTask = makeTask(callback, options);
+    this._scheduler.addTask(newTask);
+  }
+};
+
+// src/scheduler/core/actuator.ts
+var Actuator = class {
+  constructor(_taskQueue, _scheduler) {
+    this._taskQueue = _taskQueue;
+    this._scheduler = _scheduler;
+  }
+  workLoop(hasTimeRemaining, initialTime, deadline) {
+    let currentTime = initialTime;
+    this._taskQueue.advance(currentTime);
+    let currentTask = this._taskQueue.waitingTasks.peek();
+    while (currentTask !== null) {
+      if (currentTask.getExpirationTime() > currentTime && (!hasTimeRemaining || this._scheduler.shouldYieldToHost(deadline))) {
+        break;
+      }
+      if (currentTask.getCallback() === void 0) {
+        this._taskQueue.waitingTasks.remove();
+      } else {
+        const callback = currentTask.getCallback();
+        const didUserCallbackTimeout = currentTask.getExpirationTime() <= currentTime;
+        const remainingTime = deadline - currentTime;
+        currentTask.clearCallback();
+        const chunkInvoker = new ChunkScheduler(currentTask, this._scheduler);
+        callback(chunkInvoker, didUserCallbackTimeout, remainingTime);
+        if (!chunkInvoker.needContinue) {
+          this._taskQueue.waitingTasks.remove();
+        }
+        currentTime = getCurrentTime();
+        this._taskQueue.advance(currentTime);
+      }
+      currentTask = this._taskQueue.waitingTasks.peek();
+    }
+    if (currentTask !== null) {
+      return true;
+    }
+    this._scheduler.requestHostTimeout(currentTime);
+    return false;
+  }
+};
+
+// src/structure/min-heap.ts
+var MinHeap = class {
+  constructor(compareFunction) {
+    this._heap = [];
+    if (compareFunction) {
+      this._compare = compareFunction;
+    } else {
+      this._compare = (a, b) => {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+      };
+    }
+  }
+  insert(value) {
+    this._heap.push(value);
+    this._siftUp();
+  }
+  peek() {
+    return this._heap.length > 0 ? this._heap[0] : null;
+  }
+  remove() {
+    if (this._heap.length === 0) return null;
+    if (this._heap.length === 1) return this._heap.pop();
+    const item = this._heap[0];
+    this._heap[0] = this._heap.pop();
+    this._siftDown();
+    return item;
+  }
+  size() {
+    return this._heap.length;
+  }
+  clear() {
+    this._heap.length = 0;
+  }
+  _getLeftChildIndex(parentIndex) {
+    return 2 * parentIndex + 1;
+  }
+  _getRightChildIndex(parentIndex) {
+    return 2 * parentIndex + 2;
+  }
+  _getParentIndex(childIndex) {
+    return Math.floor((childIndex - 1) / 2);
+  }
+  _swap(indexOne, indexTwo) {
+    [this._heap[indexOne], this._heap[indexTwo]] = [this._heap[indexTwo], this._heap[indexOne]];
+  }
+  _siftUp() {
+    let index = this._heap.length - 1;
+    while (index > 0 && this._compare(this._heap[this._getParentIndex(index)], this._heap[index]) > 0) {
+      const parentIndex = this._getParentIndex(index);
+      this._swap(index, parentIndex);
+      index = parentIndex;
+    }
+  }
+  _siftDown() {
+    let index = 0;
+    let smallerChildIndex = this._getLeftChildIndex(index);
+    while (smallerChildIndex < this._heap.length) {
+      const rightChildIndex = this._getRightChildIndex(index);
+      if (rightChildIndex < this._heap.length && this._compare(this._heap[rightChildIndex], this._heap[smallerChildIndex]) < 0) {
+        smallerChildIndex = rightChildIndex;
+      }
+      if (this._compare(this._heap[index], this._heap[smallerChildIndex]) <= 0) {
+        break;
+      }
+      this._swap(index, smallerChildIndex);
+      index = smallerChildIndex;
+      smallerChildIndex = this._getLeftChildIndex(index);
+    }
+  }
+};
+
+// src/scheduler/core/task-queue.ts
+function compare(lhs, rhs) {
+  return lhs.getSortIndex() - rhs.getSortIndex();
+}
+var TaskQueue = class {
+  constructor() {
+    // 延时任务
+    this._timerTasks = new MinHeap(compare);
+    // 等待执行的任务
+    this._waitingTasks = new MinHeap(compare);
+  }
+  get timerTasks() {
+    return this._timerTasks;
+  }
+  get waitingTasks() {
+    return this._waitingTasks;
+  }
+  advance(currentTime) {
+    let task = this._timerTasks.peek();
+    while (task !== null) {
+      if (task.getCallback() === null) {
+        this._timerTasks.remove();
+      } else if (task.getStartTime() <= currentTime) {
+        this._timerTasks.remove();
+        task.setSortIndex(task.getExpirationTime());
+        this._waitingTasks.insert(task);
+      } else {
+        return;
+      }
+      task = this._timerTasks.peek();
+    }
+  }
+};
+
+// src/scheduler/executor/abstract-executor.ts
+var AbstractExecutor = class {
+  constructor() {
+    this._timeoutId = -1;
+    this._deadline = 0;
+    this._yieldInterval = 16;
+  }
+  get deadline() {
+    return this._deadline;
+  }
+  setFrameRate(fps) {
+    lvAssert(fps > 0 && fps <= 125);
+    this._yieldInterval = Math.floor(1e3 / fps);
+  }
+  resetFrameRate() {
+    this._yieldInterval = 16;
+  }
+  requestHostTimeout(fn, delayMs) {
+    lvAssert(this._timeoutId === -1, "has request host timeout.");
+    clearTimeout(this._timeoutId);
+    this._timeoutId = setTimeout(() => {
+      this._timeoutId = -1;
+      fn();
+    }, delayMs);
+  }
+  cancelHostTimeout() {
+    clearTimeout(this._timeoutId);
+    this._timeoutId = -1;
+  }
+};
+
+// src/scheduler/executor/idle-callback-executor.ts
+var IdleCallbackExecutor = class extends AbstractExecutor {
+  constructor() {
+    super();
+    this._flushCallback = () => {
+      if (!this._scheduledCallback) {
+        return;
+      }
+      const currentTime = getCurrentTime();
+      const deadline = currentTime + this._yieldInterval;
+      try {
+        const hasMoreWork = this._scheduledCallback(true, currentTime, deadline);
+        if (!hasMoreWork) {
+          this._scheduledCallback = void 0;
+          this._disposable = void 0;
+        } else {
+          this._disposable = this._runWhenIdle(this._flushCallback);
+        }
+      } catch (err) {
+        this._disposable = this._runWhenIdle(this._flushCallback);
+        throw err;
+      }
+    };
+    if (typeof requestIdleCallback !== "function" || typeof cancelIdleCallback !== "function") {
+      this._runWhenIdle = (runner) => {
+        let disposed = false;
+        setTimeout(() => {
+          if (disposed) {
+            return;
+          }
+          const end = Date.now() + 15;
+          runner(
+            Object.freeze({
+              didTimeout: true,
+              timeRemaining() {
+                return Math.max(0, end - Date.now());
+              }
+            })
+          );
+        });
+        return {
+          dispose() {
+            if (disposed) {
+              return;
+            }
+            disposed = true;
+          }
+        };
+      };
+    } else {
+      this._runWhenIdle = (runner, timeout) => {
+        const handle = requestIdleCallback(
+          runner,
+          typeof timeout === "number" ? { timeout } : void 0
+        );
+        let disposed = false;
+        return {
+          dispose() {
+            if (disposed) {
+              return;
+            }
+            disposed = true;
+            cancelIdleCallback(handle);
+          }
+        };
+      };
+    }
+  }
+  requestHostCallback(fn) {
+    this._scheduledCallback = fn;
+    if (!this._disposable) {
+      this._disposable = this._runWhenIdle(this._flushCallback);
+    }
+  }
+  cancelHostCallback() {
+    this._disposable?.dispose();
+    this._scheduledCallback = void 0;
+    this._disposable = void 0;
+  }
+};
+
+// src/scheduler/executor/post-message-executor.ts
+var PostMessageExecutor = class extends AbstractExecutor {
+  constructor() {
+    super();
+    this._isMessageLoopRunning = false;
+    this._channel = new MessageChannel();
+    this._flushCallback = () => {
+      if (!this._scheduledCallback) {
+        this._isMessageLoopRunning = false;
+        return;
+      }
+      const currentTime = getCurrentTime();
+      const deadline = currentTime + this._yieldInterval;
+      try {
+        const hasMoreWork = this._scheduledCallback(true, currentTime, deadline);
+        if (!hasMoreWork) {
+          this._isMessageLoopRunning = false;
+          this._scheduledCallback = void 0;
+        } else {
+          this._channel.port2.postMessage(null);
+        }
+      } catch (err) {
+        this._channel.port2.postMessage(null);
+        throw err;
+      }
+    };
+    this._channel.port1.onmessage = () => {
+      this._flushCallback();
+    };
+  }
+  requestHostCallback(fn) {
+    this._scheduledCallback = fn;
+    if (!this._isMessageLoopRunning) {
+      this._isMessageLoopRunning = true;
+      this._channel.port2.postMessage(null);
+    }
+  }
+  cancelHostCallback() {
+    this._scheduledCallback = void 0;
+  }
+};
+
+// src/scheduler/executor/make-executor.ts
+function makeExecutor() {
+  try {
+    if (global.window) {
+      return new PostMessageExecutor();
+    }
+  } catch (e) {
+  }
+  return new IdleCallbackExecutor();
+}
+
+// src/scheduler/core/scheduler.ts
+var Scheduler = class {
+  constructor() {
+    this._isHostTimeoutScheduled = false;
+    this._isHostCallbackScheduled = false;
+    this._isWorking = false;
+    this._enableInputPending = true;
+    this._executor = makeExecutor();
+    this._taskQueue = new TaskQueue();
+    this._actuator = new Actuator(this._taskQueue, this);
+    /**
+     * 是否需要让出事件给宿主
+     */
+    this.shouldYieldToHost = (() => {
+      try {
+        if (global.navigator?.scheduling?.isInputPending !== void 0) {
+          const { scheduling } = global.navigator;
+          return (deadline) => {
+            if (this._enableInputPending && scheduling.isInputPending()) {
+              return true;
+            }
+            return getCurrentTime() >= deadline;
+          };
+        }
+      } catch (e) {
+      }
+      return (deadline) => {
+        return getCurrentTime() >= deadline;
+      };
+    })();
+    this._handleHostTimeout = () => {
+      this._isHostTimeoutScheduled = false;
+      const currentTime = getCurrentTime();
+      this._taskQueue.advance(currentTime);
+      if (this._isHostCallbackScheduled) {
+        return;
+      }
+      if (this._taskQueue.waitingTasks.peek() !== null) {
+        this._isHostCallbackScheduled = true;
+        this._executor.requestHostCallback(this._handleHostCallback);
+        return;
+      }
+      this._requestHostTimeout(currentTime);
+    };
+    this._handleHostCallback = (hasTimeRemaining, initialTime, deadline) => {
+      this._isHostCallbackScheduled = false;
+      if (this._isHostTimeoutScheduled) {
+        this._isHostTimeoutScheduled = false;
+        this._executor.cancelHostTimeout();
+      }
+      this._isWorking = true;
+      try {
+        return this._actuator.workLoop(hasTimeRemaining, initialTime, deadline);
+      } finally {
+        this._isWorking = false;
+      }
+    };
+  }
+  get taskQueue() {
+    return this._taskQueue;
+  }
+  get executor() {
+    return this._executor;
+  }
+  /**
+   * 设置是否开启InputPending
+   */
+  setEnableInputPending(val) {
+    this._enableInputPending = val;
+  }
+  /**
+   * 调度器中添加任务
+   */
+  addTask(task) {
+    const currentTime = getCurrentTime();
+    if (task.getStartTime() > currentTime) {
+      task.setSortIndex(task.getStartTime());
+      this._taskQueue.timerTasks.insert(task);
+      if (this._taskQueue.waitingTasks.peek() === null && task === this._taskQueue.timerTasks.peek()) {
+        if (this._isHostTimeoutScheduled) {
+          this._executor.cancelHostTimeout();
+        } else {
+          this._isHostTimeoutScheduled = true;
+        }
+        this._executor.requestHostTimeout(this._handleHostTimeout, task.getStartTime() - currentTime);
+      }
+    } else {
+      task.setSortIndex(task.getExpirationTime());
+      this._taskQueue.waitingTasks.insert(task);
+      if (!this._isHostCallbackScheduled && !this._isWorking) {
+        this._isHostCallbackScheduled = true;
+        this._executor.requestHostCallback(this._handleHostCallback);
+      }
+    }
+  }
+  /**
+   * 尝试启动异步任务调度
+   */
+  requestHostTimeout(currentTime) {
+    this._requestHostTimeout(currentTime);
+  }
+  _requestHostTimeout(currentTime) {
+    lvAssert(!this._isHostCallbackScheduled);
+    lvAssert(!this._isHostTimeoutScheduled);
+    const firstTimerTask = this._taskQueue.timerTasks.peek();
+    if (firstTimerTask !== null) {
+      this._isHostTimeoutScheduled = true;
+      this._executor.requestHostTimeout(this._handleHostTimeout, firstTimerTask.getStartTime() - currentTime);
+    }
+  }
+};
+var scheduler;
+function getScheduler() {
+  if (!scheduler) {
+    scheduler = new Scheduler();
+  }
+  return scheduler;
+}
+
+// src/scheduler/callback-token.ts
+var CallbackToken = class {
+  constructor(_task) {
+    this._task = _task;
+  }
+  dispose() {
+    this._task.clearCallback();
+  }
+  updatePriorityLevel(priorityLevel) {
+    const callback = this._task.getCallback();
+    if (!callback) {
+      return;
+    }
+    this._task.clearCallback();
+    const newTask = makeTask(callback, {
+      priorityLevel
+    });
+    const startTime = this._task.getStartTime();
+    const timeout = getTimeout(priorityLevel);
+    const expirationTime = startTime + timeout;
+    newTask.setStartTime(startTime);
+    newTask.setExpirationTime(expirationTime);
+    getScheduler().addTask(newTask);
+    this._task = newTask;
+  }
+};
+
+// src/scheduler/lv-scheduler-callback.ts
+function lvSchedulerCallback(callback, options = {}) {
+  const newTask = makeTask(callback, options);
+  getScheduler().addTask(newTask);
+  return new CallbackToken(newTask);
+}
+
+// src/structure/linked-list.ts
+var ListNode = class {
+  constructor(value, next = null, prev = null) {
+    this.value = value;
+    this.next = next;
+    this.prev = prev;
+  }
+};
+var LinkedList = class {
+  constructor() {
+    this._head = null;
+    this._tail = null;
+    this._count = 0;
+  }
+  get size() {
+    return this._count;
+  }
+  get firstNode() {
+    return this._head;
+  }
+  isEmpty() {
+    return this._head === null;
+  }
+  clear() {
+    let current = this._head;
+    while (current !== null) {
+      const next = current.next;
+      current.prev = null;
+      current.next = null;
+      current = next;
+    }
+    this._head = null;
+    this._tail = null;
+    this._count = 0;
+  }
+  unshift(value) {
+    const node = new ListNode(value);
+    if (this.isEmpty()) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      const oldHead = this._head;
+      this._head = node;
+      node.next = oldHead;
+      oldHead.prev = node;
+    }
+    this._count++;
+    return this;
+  }
+  push(value) {
+    const node = new ListNode(value);
+    if (this.isEmpty()) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      const oldTail = this._tail;
+      this._tail = node;
+      node.prev = oldTail;
+      oldTail.next = node;
+    }
+    this._count++;
+    return this;
+  }
+  shift() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const node = this._head;
+    const value = node.value;
+    this._remove(node);
+    return value;
+  }
+  pop() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const node = this._tail;
+    const value = node.value;
+    this._remove(node);
+    return value;
+  }
+  toArray() {
+    const result = [];
+    for (const value of this) {
+      result.push(value);
+    }
+    return result;
+  }
+  *[Symbol.iterator]() {
+    let current = this._head;
+    while (current !== null) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  _remove(node) {
+    if (node.prev === null && node.next === null && node !== this._head && node !== this._tail) {
+      return;
+    }
+    if (node === this._head) {
+      this._head = node.next;
+      if (this._head) {
+        this._head.prev = null;
+      }
+    }
+    if (node === this._tail) {
+      this._tail = node.prev;
+      if (this._tail) {
+        this._tail.next = null;
+      }
+    }
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+    this._count--;
+  }
+};
+
+// src/event/disposable-linked-list.ts
+var DisposableLinkedList = class extends LinkedList {
+  unshiftAndGetDisposableNode(value) {
+    this.unshift(value);
+    const node = this._head;
+    let hasRemoved = false;
+    return () => {
+      if (!hasRemoved) {
+        hasRemoved = true;
+        super._remove(node);
+      }
+    };
+  }
+  pushAndGetDisposableNode(value) {
+    this.push(value);
+    const node = this._tail;
+    let hasRemoved = false;
+    return () => {
+      if (!hasRemoved) {
+        hasRemoved = true;
+        super._remove(node);
+      }
+    };
+  }
+};
+
+// src/event/error-handler.ts
+function asyncUnexpectedError(e) {
+  setTimeout(() => {
+    throw e;
+  }, 0);
+}
+
+// src/event/emitter.ts
+var Listener = class {
+  constructor(callback, callbackThis) {
+    this._callback = callback;
+    this._callbackThis = callbackThis;
+  }
+  invoke(...args) {
+    this._callback.call(this._callbackThis, ...args);
+  }
+};
+var EventDeliveryQueueElement = class {
+  constructor(emitter, listener, event) {
+    this.emitter = emitter;
+    this.listener = listener;
+    this.event = event;
+  }
+};
+var EventDeliveryQueue = class {
+  constructor(_onListenerError = asyncUnexpectedError) {
+    this._onListenerError = _onListenerError;
+    this._queue = new DisposableLinkedList();
+  }
+  get size() {
+    return this._queue.size;
+  }
+  push(emitter, listener, event) {
+    this._queue.push(new EventDeliveryQueueElement(emitter, listener, event));
+  }
+  clear(emitter) {
+    const newQueue = new DisposableLinkedList();
+    for (const element of this._queue) {
+      if (element.emitter !== emitter) {
+        newQueue.push(element);
+      }
+    }
+    this._queue = newQueue;
+  }
+  deliver() {
+    while (this._queue.size > 0) {
+      const element = this._queue.shift();
+      try {
+        element.listener.invoke(...element.event);
+      } catch (e) {
+        this._onListenerError(e);
+      }
+    }
+  }
+};
+var Emitter = class {
+  constructor(options) {
+    this._disposed = false;
+    this._options = options;
+  }
+  get event() {
+    if (this._event) {
+      return this._event;
+    }
+    this._event = (callback, thisArgs) => {
+      const listener = new Listener(callback, thisArgs);
+      if (!this._listeners) {
+        this._listeners = new DisposableLinkedList();
+      }
+      const removeListener = this._listeners.pushAndGetDisposableNode(listener);
+      if (this._options?.onAddListener) {
+        this._options.onAddListener(this, callback, thisArgs);
+      }
+      const result = () => {
+        if (!this._disposed) {
+          removeListener();
+          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 || this._listeners.size === 0) {
+      return;
+    }
+    if (this._listeners.size === 1) {
+      const listener = this._listeners.firstNode;
+      try {
+        listener.value.invoke(...event);
+      } catch (e) {
+        if (this._options?.onListenerError) {
+          this._options.onListenerError(e);
+        } else {
+          asyncUnexpectedError(e);
+        }
+      }
+      return;
+    }
+    this._deliveryQueue ?? (this._deliveryQueue = new EventDeliveryQueue(this._options?.onListenerError));
+    for (const listener of this._listeners) {
+      this._deliveryQueue.push(this, listener, event);
+    }
+    this._deliveryQueue.deliver();
+  }
+};
+
+// src/event/once.ts
+function listenOnce(event) {
+  return (listener, thisArgs = null) => {
+    let didFire = false;
+    let result = void 0;
+    result = event((...args) => {
+      if (didFire) {
+        return;
+      } else if (result) {
+        result.dispose();
+      } else {
+        didFire = true;
+      }
+      return listener.call(thisArgs, ...args);
+    }, null);
+    if (didFire) {
+      result.dispose();
+    }
+    return result;
+  };
+}
+
+// src/di/idle-value.ts
+var IdleValue = class {
+  constructor(executor) {
+    this._didRun = false;
+    this._executor = () => {
+      try {
+        this._value = executor();
+      } catch (err) {
+        this._error = err;
+        throw err;
+      } finally {
+        this._didRun = true;
+        if (this._value && this._executorEmitter) {
+          this._executorEmitter.fire();
+        }
+      }
+    };
+    this._handle = lvSchedulerCallback(() => this._executor(), {
+      priorityLevel: 4 /* IdlePriority */
+    });
+  }
+  get value() {
+    if (!this._didRun) {
+      this._handle.dispose();
+      this._executor();
+    }
+    if (this._error) {
+      throw this._error;
+    }
+    return this._value;
+  }
+  get isInitialized() {
+    return this._didRun;
+  }
+  get onExecutor() {
+    if (!this._executorEmitter) {
+      this._executorEmitter = new Emitter();
+    }
+    return this._executorEmitter.event;
+  }
+  dispose() {
+    this._handle.dispose();
+  }
+};
+
+// src/structure/graph.ts
+var Node = class {
+  constructor(key, data) {
+    this.key = key;
+    this.data = data;
+    this.incoming = /* @__PURE__ */ new Map();
+    this.outgoing = /* @__PURE__ */ new Map();
+  }
+};
+var Graph = class {
+  constructor(_hashFn) {
+    this._hashFn = _hashFn;
+    this._nodes = /* @__PURE__ */ new Map();
+  }
+  // 寻找所有的叶子节点
+  leafs() {
+    const ret = [];
+    for (const node of this._nodes.values()) {
+      if (node.outgoing.size === 0) {
+        ret.push(node);
+      }
+    }
+    return ret;
+  }
+  // 插入一条边
+  insertEdge(from, to) {
+    const fromNode = this.lookupOrInsertNode(from);
+    const toNode = this.lookupOrInsertNode(to);
+    fromNode.outgoing.set(toNode.key, toNode);
+    toNode.incoming.set(fromNode.key, fromNode);
+  }
+  // 移除某个节点
+  removeNode(data) {
+    const key = this._hashFn(data);
+    this._nodes.delete(key);
+    for (const node of this._nodes.values()) {
+      node.outgoing.delete(key);
+      node.incoming.delete(key);
+    }
+  }
+  // 查找某个节点
+  lookup(data) {
+    return this._nodes.get(this._hashFn(data));
+  }
+  // 查找某个节点，不存在则插入
+  lookupOrInsertNode(data) {
+    const key = this._hashFn(data);
+    let node = this._nodes.get(key);
+    if (!node) {
+      node = new Node(key, data);
+      this._nodes.set(key, node);
+    }
+    return node;
+  }
+  isEmpty() {
+    return this._nodes.size === 0;
+  }
+  toString() {
+    const data = [];
+    for (const [key, value] of this._nodes) {
+      data.push(
+        `${key}
+	(-> incoming)[${[...value.incoming.keys()].join(", ")}]
+	(outgoing ->)[${[
+          ...value.outgoing.keys()
+        ].join(",")}]
+`
+      );
+    }
+    return data.join("\n");
+  }
+  findCycleSlow() {
+    for (const [id, node] of this._nodes) {
+      const seen = /* @__PURE__ */ new Set([id]);
+      const res = this._findCycle(node, seen);
+      if (res) {
+        return res;
+      }
+    }
+    return void 0;
+  }
+  _findCycle(node, seen) {
+    for (const [id, outgoing] of node.outgoing) {
+      if (seen.has(id)) {
+        return [...seen, id].join(" -> ");
+      }
+      seen.add(id);
+      const value = this._findCycle(outgoing, seen);
+      if (value) {
+        return value;
+      }
+      seen.delete(id);
+    }
+    return void 0;
+  }
+};
+
+// src/di/service-ownership-collection.ts
+var ServiceOwnership = /* @__PURE__ */ ((ServiceOwnership2) => {
+  ServiceOwnership2[ServiceOwnership2["Owned"] = 1] = "Owned";
+  ServiceOwnership2[ServiceOwnership2["Reference"] = 2] = "Reference";
+  return ServiceOwnership2;
+})(ServiceOwnership || {});
+var ServiceOwnershipCollection = class {
+  constructor(...entries) {
+    this._entries = /* @__PURE__ */ new Map();
+    for (const [id, service] of entries) {
+      this.set(id, service);
+    }
+  }
+  get entries() {
+    return this._entries;
+  }
+  set(id, ownership) {
+    this._entries.set(id, ownership);
+  }
+  has(id) {
+    return this._entries.has(id);
+  }
+  get(id) {
+    return this._entries.get(id);
+  }
+};
+
+// src/di/service-collection.ts
+var ServiceCollection = class {
+  constructor(options) {
+    this._entries = /* @__PURE__ */ new Map();
+    for (const [id, service] of options?.entries || []) {
+      this.set(id, service);
+    }
+    if (options?.ownership) {
+      this._ownership = options.ownership;
+    }
+  }
+  get entries() {
+    return this._entries;
+  }
+  get ownerships() {
+    return this._ownership?.entries;
+  }
+  set(id, instanceOrDescriptor) {
+    this._entries.set(id, instanceOrDescriptor);
+  }
+  has(id) {
+    return this._entries.has(id);
+  }
+  get(id) {
+    return this._entries.get(id);
+  }
+};
+
+// src/di/proxy-builder.ts
+function makeProxy(valueWrapper, ctor) {
+  const wrapper = /* @__PURE__ */ Object.create(null);
+  const result = new Proxy(wrapper, {
+    get(target, key) {
+      if (key in target) {
+        return target[key];
+      }
+      const obj = valueWrapper.value;
+      let prop = obj[key];
+      if (typeof prop !== "function") {
+        return prop;
+      }
+      prop = prop.bind(obj);
+      target[key] = prop;
+      return prop;
+    },
+    set(_target, p, value) {
+      const obj = valueWrapper.value;
+      obj[p] = value;
+      return true;
+    }
+  });
+  wrapper.__originClass__ = ctor;
+  listenOnce(valueWrapper.onExecutor)(() => {
+    wrapper.__origin__ = valueWrapper.value;
+  });
+  return result;
+}
+
+// src/di/trace.ts
+var _Trace = class _Trace {
+  constructor(type, name) {
+    this._start = Date.now();
+    this._dep = [];
+    this._type = type;
+    this._name = name;
+  }
+  static traceInvocation(_enableTracing, ctor) {
+    return !_enableTracing ? _Trace._None : new _Trace(2 /* Invocation */, ctor.name || new Error().stack.split("\n").slice(3, 4).join("\n"));
+  }
+  static traceCreation(_enableTracing, ctor) {
+    return !_enableTracing ? _Trace._None : new _Trace(1 /* Creation */, ctor.name);
+  }
+  branch(id, first) {
+    const child = new _Trace(3 /* Branch */, id.toString());
+    this._dep.push([id, first, child]);
+    return child;
+  }
+  stop() {
+    const dur = Date.now() - this._start;
+    _Trace._totals += dur;
+    let causedCreation = false;
+    function printChild(n, trace) {
+      const res = [];
+      const prefix = new Array(n + 1).join("	");
+      for (const [id, first, child] of trace._dep) {
+        if (first && child) {
+          causedCreation = true;
+          res.push(`${prefix}CREATES -> ${id}`);
+          const nested = printChild(n + 1, child);
+          if (nested) {
+            res.push(nested);
+          }
+        } else {
+          res.push(`${prefix}uses -> ${id}`);
+        }
+      }
+      return res.join("\n");
+    }
+    const lines = [
+      `${this._type === 1 /* Creation */ ? "CREATE" : "CALL"} ${this._name}`,
+      `${printChild(1, this)}`,
+      `DONE, took ${dur.toFixed(2)}ms (grand total ${_Trace._totals.toFixed(2)}ms)`
+    ];
+    if (dur > 2 || causedCreation) {
+      _Trace.all.add(lines.join("\n"));
+    }
+  }
+};
+_Trace.all = /* @__PURE__ */ new Set();
+_Trace._None = new class extends _Trace {
+  constructor() {
+    super(0 /* None */, null);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  stop() {
+  }
+  branch() {
+    return this;
+  }
+}();
+_Trace._totals = 0;
+var Trace = _Trace;
+
+// src/di/instantiation-service.ts
+var _enableAllTracing = false;
+var CyclicDependencyError = class extends Error {
+  constructor(graph) {
+    super("cyclic dependency between services");
+    this.message = graph.findCycleSlow() ?? `UNABLE to detect cycle, dumping graph: 
+${graph.toString()}`;
+  }
+};
+var InstantiationErrorType = /* @__PURE__ */ ((InstantiationErrorType2) => {
+  InstantiationErrorType2["UnknownDependency"] = "UnknownDependency";
+  return InstantiationErrorType2;
+})(InstantiationErrorType || {});
+function getService(instantiationService, id) {
+  return instantiationService.invokeFunction((accessor) => {
+    return accessor.get(id);
+  });
+}
+var InstantiationService = class _InstantiationService {
+  constructor(services = new ServiceCollection(), parent, enableTracing = _enableAllTracing) {
+    this._childs = /* @__PURE__ */ new Set();
+    // 记录当前正在创建的服务，防止循环依赖
+    this._activeInstantiations = /* @__PURE__ */ new Set();
+    this._emitter = null;
+    this._services = services;
+    this._services.set(IInstantiationService, this);
+    this._parent = parent;
+    if (this._parent) {
+      this._parent._childs.add(this);
+    }
+    this._enableTracing = enableTracing;
+    if (enableTracing) {
+      this._globalGraph = parent?._globalGraph ?? new Graph((e) => e);
+    }
+  }
+  get services() {
+    return this._services;
+  }
+  // 仅限 Flow 调用
+  get onError() {
+    if (!this._emitter) {
+      this._emitter = new Emitter();
+    }
+    return this._emitter.event;
+  }
+  // 创建子instantiationService
+  createChild(services) {
+    return new _InstantiationService(services, this, this._enableTracing);
+  }
+  // 提供通过instantiationService直接获取到内部服务的能力
+  // 返回servicesAccessor这一视图类，并不暴露instantiationService内部接口
+  invokeFunction(fn, ...args) {
+    const _trace = Trace.traceInvocation(this._enableTracing, fn);
+    let _done = false;
+    try {
+      const accessor = {
+        get: (id) => {
+          if (_done) {
+            throw new Error("service accessor is only valid during the invocation of its target method");
+          }
+          const result = this._getOrCreateServiceInstance(id, _trace);
+          if (!result) {
+            this._handleError({
+              errorType: "UnknownDependency" /* UnknownDependency */,
+              issuer: "service-accessor",
+              dependencyId: `${id}`,
+              message: `[invokeFunction] unknown service '${id}'`
+            });
+          }
+          return result;
+        }
+      };
+      return fn(accessor, ...args);
+    } finally {
+      _done = true;
+      _trace.stop();
+    }
+  }
+  createInstance(ctorOrDescriptor, ...rest) {
+    let _trace, result;
+    if (ctorOrDescriptor instanceof SyncDescriptor) {
+      _trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor.ctor);
+      result = this._createInstance(
+        ctorOrDescriptor.ctor,
+        ctorOrDescriptor.staticArguments.concat(rest),
+        _trace
+      );
+    } else {
+      _trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor);
+      result = this._createInstance(ctorOrDescriptor, rest, _trace);
+    }
+    _trace.stop();
+    return result;
+  }
+  dispose() {
+    for (const child of this._childs) {
+      child.dispose();
+    }
+    this._parent?._childs.delete(this);
+    for (const [identifier, instanceOrDescriptor] of this._services.entries) {
+      if (instanceOrDescriptor instanceof SyncDescriptor) {
+        continue;
+      }
+      if (instanceOrDescriptor === this) {
+        continue;
+      }
+      if (instanceOrDescriptor.__origin__ === this) {
+        continue;
+      }
+      if (isDisposable(instanceOrDescriptor)) {
+        const ownerShip = this._services.ownerships?.get(identifier);
+        switch (ownerShip) {
+          case 2 /* Reference */:
+            break;
+          case 1 /* Owned */:
+          default:
+            instanceOrDescriptor.dispose();
+            break;
+        }
+      }
+    }
+  }
+  // 创建实例
+  _createInstance(ctor, args = [], _trace) {
+    const serviceDependencies = getServiceDependencies(ctor).sort((a, b) => a.index - b.index);
+    const serviceArgs = [];
+    for (const dependency of serviceDependencies) {
+      const service = this._getOrCreateServiceInstance(dependency.id, _trace);
+      if (!service) {
+        this._handleError({
+          errorType: "UnknownDependency" /* UnknownDependency */,
+          issuer: `create-instance-${ctor.name}`,
+          dependencyId: `${dependency.id}`,
+          message: `[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`
+        });
+      }
+      serviceArgs.push(service);
+    }
+    const firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length;
+    if (args.length !== firstServiceArgPos) {
+      Logger.trace(
+        `[createInstance] First service dependency of ${ctor.name} at position ${firstServiceArgPos + 1} conflicts with ${args.length} static arguments`
+      );
+      const delta = firstServiceArgPos - args.length;
+      if (delta > 0) {
+        args = args.concat(new Array(delta));
+      } else {
+        args = args.slice(0, firstServiceArgPos);
+      }
+    }
+    return Reflect.construct(ctor, args.concat(serviceArgs));
+  }
+  // 保存服务实例
+  _setServiceInstance(id, instance) {
+    if (this._services.get(id) instanceof SyncDescriptor) {
+      this._services.set(id, instance);
+    } else if (this._parent) {
+      this._parent._setServiceInstance(id, instance);
+    } else {
+      throw new Error("illegalState - setting UNKNOWN service instance");
+    }
+  }
+  // 获取服务实例或者描述符
+  _getServiceInstanceOrDescriptor(id) {
+    const instanceOrDesc = this._services.get(id);
+    if (!instanceOrDesc && this._parent) {
+      return this._parent._getServiceInstanceOrDescriptor(id);
+    } else {
+      return instanceOrDesc;
+    }
+  }
+  // 获取服务实例，没有的话就创建
+  _getOrCreateServiceInstance(id, _trace) {
+    if (this._globalGraph && this._globalGraphImplicitDependency) {
+      this._globalGraph.insertEdge(this._globalGraphImplicitDependency, String(id));
+    }
+    const thing = this._getServiceInstanceOrDescriptor(id);
+    if (thing instanceof SyncDescriptor) {
+      return this._safeCreateAndCacheServiceInstance(id, thing, _trace.branch(id, true));
+    } else {
+      _trace.branch(id, false);
+      return thing;
+    }
+  }
+  // 安全的创建并且记录在缓存中
+  _safeCreateAndCacheServiceInstance(id, desc, _trace) {
+    if (this._activeInstantiations.has(id)) {
+      throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);
+    }
+    this._activeInstantiations.add(id);
+    try {
+      return this._createAndCacheServiceInstance(id, desc, _trace);
+    } finally {
+      this._activeInstantiations.delete(id);
+    }
+  }
+  // 非安全创建并记录在缓存中
+  // 核心方法，服务创建的最基础流程
+  _createAndCacheServiceInstance(id, desc, _trace) {
+    const graph = new Graph((data) => data.id.toString());
+    let cycleCount = 0;
+    const stack = [{ id, desc, _trace }];
+    while (stack.length) {
+      const item = stack.pop();
+      graph.lookupOrInsertNode(item);
+      if (cycleCount++ > 1e3) {
+        throw new CyclicDependencyError(graph);
+      }
+      for (const dependency of getServiceDependencies(item.desc.ctor)) {
+        const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
+        if (!instanceOrDesc) {
+          this._handleError({
+            errorType: "UnknownDependency" /* UnknownDependency */,
+            issuer: `create-service-${id}`,
+            dependencyId: `${dependency.id}`,
+            message: `[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`
+          });
+        }
+        this._globalGraph?.insertEdge(String(item.id), String(dependency.id));
+        if (instanceOrDesc instanceof SyncDescriptor) {
+          const d = {
+            id: dependency.id,
+            desc: instanceOrDesc,
+            _trace: item._trace.branch(dependency.id, true)
+          };
+          graph.insertEdge(item, d);
+          stack.push(d);
+        }
+      }
+    }
+    while (true) {
+      const leafs = graph.leafs();
+      if (leafs.length === 0) {
+        if (!graph.isEmpty()) {
+          throw new CyclicDependencyError(graph);
+        }
+        break;
+      }
+      for (const { data } of leafs) {
+        const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);
+        if (instanceOrDesc instanceof SyncDescriptor) {
+          const instance = this._createServiceInstanceWithOwner(
+            data.id,
+            data.desc.ctor,
+            data.desc.staticArguments,
+            data.desc.supportsDelayedInstantiation,
+            data._trace
+          );
+          this._setServiceInstance(data.id, instance);
+        }
+        graph.removeNode(data);
+      }
+    }
+    return this._getServiceInstanceOrDescriptor(id);
+  }
+  // 创建服务实例（会判断在哪层instantiation中判断）
+  _createServiceInstanceWithOwner(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
+    if (this._services.get(id) instanceof SyncDescriptor) {
+      return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace);
+    } else if (this._parent) {
+      return this._parent._createServiceInstanceWithOwner(
+        id,
+        ctor,
+        args,
+        supportsDelayedInstantiation,
+        _trace
+      );
+    } else {
+      throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);
+    }
+  }
+  // 准备创建服务实例
+  _createServiceInstance(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
+    if (!supportsDelayedInstantiation) {
+      return this._createService(ctor, args, _trace);
+    }
+    const idle = new IdleValue(() => this._createService(ctor, args, _trace));
+    return makeProxy(idle, ctor);
+  }
+  // 创建服务
+  _createService(ctor, args = [], _trace) {
+    const service = this._createInstance(ctor, args, _trace);
+    if (isDisposable(service)) ;
+    return service;
+  }
+  // 处理错误
+  _handleError(errorData) {
+    let topInstantiationService = this;
+    while (topInstantiationService._parent) {
+      topInstantiationService = topInstantiationService._parent;
+    }
+    if (topInstantiationService._emitter) {
+      topInstantiationService._emitter.fire(errorData);
+    }
+    throw new Error(errorData.message);
+  }
+};
+
+// src/di/service-registry.ts
+var ServiceRegistry = class {
+  constructor(config = {}) {
+    this._registry = [];
+    this._serviceOwnership = new ServiceOwnershipCollection();
+    // 重复检测的id记录
+    this._ids = /* @__PURE__ */ new Set();
+    this._checkDuplicate = config.checkDuplicate ?? false;
+  }
+  get registry() {
+    return this._registry;
+  }
+  register(id, ctorOrDescriptor, supportsDelayedInstantiation) {
+    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
+      ctorOrDescriptor = new SyncDescriptor(
+        ctorOrDescriptor,
+        [],
+        Boolean(supportsDelayedInstantiation)
+      );
+    }
+    if (this._checkDuplicate) {
+      lvAssert(!this._ids.has(id.toString()), `service: ${id.toString()} duplicate register.`);
+      this._ids.add(id.toString());
+    }
+    this._registry.push([id, ctorOrDescriptor]);
+  }
+  /**
+   * 直接注册一个服务的实例
+   *
+   * 注意：谨慎使用，优先使用register
+   * 一般用于特殊场景：需要先于DI之前就构造了某个service
+   */
+  registerInstance(id, instance, options) {
+    if (this._checkDuplicate) {
+      lvAssert(!this._ids.has(id.toString()), `service: ${id.toString()} duplicate register.`);
+      this._ids.add(id.toString());
+    }
+    this._registry.push([id, instance]);
+    this._serviceOwnership.set(id, options?.ownership ?? 1 /* Owned */);
+  }
+  makeCollection() {
+    const serviceCollection = new ServiceCollection({
+      ownership: this._serviceOwnership
+    });
+    for (const [id, instanceOrDescriptor] of this.registry) {
+      serviceCollection.set(id, instanceOrDescriptor);
+    }
+    return serviceCollection;
+  }
+};
+
+// src/lock/capability.ts
+var Capability = class {
+  constructor() {
+    this._onUnlocked = new Emitter();
+    this._status = 0 /* Unlocked */;
+    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 {
+  constructor() {
+    this._onUnlocked = new Emitter();
+    this._status = 0 /* Unlocked */;
+    this._counter = 0;
+    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 {
+  constructor() {
+    this._onActive = new Emitter();
+    this.onActive = this._onActive.event;
+  }
+  notify() {
+    this._onActive.fire();
+  }
+};
+
+// src/lock/shared-mutex.ts
+var SharedMutex = class {
+  constructor() {
+    // 在第一道门外等待的写者
+    this._waitingWriters = [];
+  }
+  /**
+   * 是否被锁住
+   */
+  isLocked() {
+    return 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();
+  }
+  /**
+   * 等待并获取读锁
+   */
+  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();
+  }
+  /**
+   * 获取当前读者数量
+   */
+  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/di/lazy/lazy-service.ts
+exports.LazyServiceLoader = class LazyServiceLoader {
+  constructor(_instantiationService) {
+    this._instantiationService = _instantiationService;
+    this._sharedMutex = new SharedMutex();
+  }
+  get loaded() {
+    return Boolean(this._instance);
+  }
+  preload() {
+    this._getModule();
+  }
+  // 创建模块实例
+  async getInstance() {
+    await this._sharedMutex.lock();
+    try {
+      if (this._instance) {
+        return this._instance;
+      }
+      this._instance = await this._makeInstance(...this._getStaticArguments());
+      return this._instance;
+    } finally {
+      this._sharedMutex.unLock();
+    }
+  }
+  // 加载module，获取实例
+  async _makeInstance(...rest) {
+    const module = await this._getModule();
+    if (module.default) {
+      return this._instantiationService.createInstance(module.default, ...rest);
+    } else {
+      return this._instantiationService.createInstance(module, ...rest);
+    }
+  }
+  // 获取模块的静态参数，子类可以复写
+  _getStaticArguments() {
+    return [];
+  }
+};
+exports.LazyServiceLoader = __decorateClass([
+  __decorateParam(0, IInstantiationService)
+], exports.LazyServiceLoader);
+
+// src/di/lazy/idle-load.ts
+var IdleServiceLoader = class {
+  constructor(originService, staticArguments, _instantiationService) {
+    this._instantiationService = _instantiationService;
+    this._service = this._instantiationService.createInstance(originService, ...staticArguments);
+    lvSchedulerCallback(() => this._service.preload());
+  }
+  get loaded() {
+    return this._service.loaded;
+  }
+  getInstance() {
+    return this._service.getInstance();
+  }
+  preload() {
+    this._service.preload();
+  }
+};
+IdleServiceLoader = __decorateClass([
+  __decorateParam(2, IInstantiationService)
+], IdleServiceLoader);
+function makeLazyServiceIdleLoad(ctor, staticArguments = []) {
+  return new SyncDescriptor(IdleServiceLoader, [ctor, staticArguments]);
+}
+var Context = react.createContext(null);
+var InstantiationContext = (props) => {
+  return react.createElement(
+    Context.Provider,
+    { value: props.instantiationService },
+    props.children
+  );
+};
+function useService(identifier) {
+  const instantiationService = react.useContext(Context);
+  lvAssertNotNil(instantiationService, "react components need service context.");
+  const service = react.useMemo(
+    () => instantiationService.invokeFunction(
+      (servicesAccessor) => servicesAccessor.get(identifier)
+    ),
+    [instantiationService, identifier]
+  );
+  return service;
+}
+
+exports.ContainerService = InstantiationService;
+exports.IContainerService = IInstantiationService;
+exports.IInstantiationService = IInstantiationService;
+exports.InstantiationContext = InstantiationContext;
+exports.InstantiationErrorType = InstantiationErrorType;
+exports.InstantiationService = InstantiationService;
+exports.ServiceCollection = ServiceCollection;
+exports.ServiceOwnership = ServiceOwnership;
+exports.ServiceRegistry = ServiceRegistry;
+exports.SyncDescriptor = SyncDescriptor;
+exports.createDecorator = createDecorator;
+exports.getService = getService;
+exports.makeLazyServiceIdleLoad = makeLazyServiceIdleLoad;
+exports.refineServiceDecorator = refineServiceDecorator;
+exports.useService = useService;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map