@zk-tech/bedrock 0.1.1 → 0.1.3

package/dist/services/dynamic-dependency/index.js

@@ -0,0 +1,1581 @@
+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;
+}
+
+// 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");
+  }
+}
+
+// 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-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 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/services/dynamic-dependency/dynamic-dependency-service.interface.ts
+var IDynamicDependencyService = createDecorator(
+  "dynamic-dependency-service"
+);
+
+// src/services/dynamic-dependency/dynamic-dependency-service.ts
+var DynamicDependencyService = class extends InstantiationService {
+  constructor(_containerService) {
+    const collection = new ServiceCollection();
+    super(collection, _containerService);
+    this._servicesCollection = collection;
+  }
+  register(id, ctorOrDescriptor) {
+    if (this._servicesCollection.has(id)) {
+      return;
+    }
+    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
+      ctorOrDescriptor = new SyncDescriptor(ctorOrDescriptor, []);
+    }
+    this._servicesCollection.set(id, ctorOrDescriptor);
+  }
+};
+DynamicDependencyService = __decorateClass([
+  __decorateParam(0, IInstantiationService)
+], DynamicDependencyService);
+
+export { DynamicDependencyService, IDynamicDependencyService };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map