@zk-tech/bedrock 0.1.3 → 0.1.4

package/dist/services/service-extension/index.js

@@ -0,0 +1,820 @@
+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/services/service-extension/descriptor.ts
+var InstantiationPhase = /* @__PURE__ */ ((InstantiationPhase2) => {
+  InstantiationPhase2[InstantiationPhase2["Eager"] = 0] = "Eager";
+  InstantiationPhase2[InstantiationPhase2["Idle"] = 1] = "Idle";
+  return InstantiationPhase2;
+})(InstantiationPhase || {});
+
+// src/di/base.ts
+var serviceIds = /* @__PURE__ */ new Map();
+var DI_TARGET = "$di$target";
+var DI_DEPENDENCIES = "$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/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);
+    }
+  }
+};
+function BRANCH_DISPOSE(from, to) {
+}
+function SET_PARENT_OF_DISPOSABLE(child, parent) {
+}
+
+// src/dispose/disposable-store.ts
+var _DisposableStore = class _DisposableStore {
+  constructor() {
+    this._toDispose = /* @__PURE__ */ new Set();
+    this._isDisposed = false;
+  }
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  dispose() {
+    if (this._isDisposed) {
+      Logger.warn(new Error("DisposableStore has disposed.").stack);
+      return;
+    }
+    this._isDisposed = true;
+    this.clear();
+  }
+  clear() {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+    for (const disposable of this._toDispose) {
+      BRANCH_DISPOSE(this.constructor.name, disposable.constructor.name);
+    }
+    const errors = [];
+    for (const disposable of this._toDispose) {
+      try {
+        disposable.dispose();
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    this._toDispose.clear();
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "find error when dispose store.");
+    }
+  }
+  add(o) {
+    if (!o) {
+      return o;
+    }
+    if (o === this) {
+      throw new Error("Cannot register a disposable on itself.");
+    }
+    if (this._isDisposed) {
+      if (!_DisposableStore.DISABLE_DISPOSED_WARNING) {
+        Logger.warn(
+          new Error(
+            "Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!"
+          ).stack
+        );
+      }
+    } else {
+      this._toDispose.add(o);
+    }
+    return o;
+  }
+};
+_DisposableStore.DISABLE_DISPOSED_WARNING = false;
+var DisposableStore = _DisposableStore;
+
+// 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 Disposable = class {
+  constructor() {
+    this._store = new DisposableStore();
+    SET_PARENT_OF_DISPOSABLE(this._store);
+  }
+  // 销毁该节点和所有的子节点
+  dispose() {
+    BRANCH_DISPOSE(this.constructor.name, this._store.constructor.name);
+    this._store.dispose();
+  }
+  // 挂载子节点
+  _register(o) {
+    if (o === this) {
+      throw new Error("Cannot register a disposable on itself!");
+    }
+    return this._store.add(o);
+  }
+};
+
+// 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/services/service-extension/extension-service.interface.ts
+var IExtensionService = createDecorator("extension");
+
+// src/services/service-extension/extension-service.ts
+var ExtensionService = class extends Disposable {
+  constructor(_instantiationService) {
+    super();
+    this._instantiationService = _instantiationService;
+    // TODO(niurouwan): 增加disposeMap
+    this._instances = /* @__PURE__ */ new Map();
+    this._pending = /* @__PURE__ */ new Map();
+  }
+  register(descriptor, onContributionReady) {
+    if (descriptor.instantiationPhase === 0 /* Eager */) {
+      this._safeCreate(descriptor);
+      onContributionReady?.(this._instances.get(descriptor.id));
+    }
+    if (descriptor.instantiationPhase === 1 /* Idle */) {
+      const disposable = lvSchedulerCallback(() => {
+        this._safeCreate(descriptor);
+        this._pending.delete(descriptor.id);
+        onContributionReady?.(this._instances.get(descriptor.id));
+      });
+      this._pending.set(descriptor.id, disposable);
+    }
+  }
+  registerInstance(id, instance) {
+    if (this._instances.has(id)) {
+      console.error("duplicate register contribution: ", id);
+      return;
+    }
+    this._instances.set(id, instance);
+  }
+  dispose() {
+    for (const [, v] of this._instances) {
+      v.dispose();
+    }
+    for (const [, v] of this._pending) {
+      v.dispose();
+    }
+    super.dispose();
+  }
+  _safeCreate(descriptor) {
+    if (this._instances.has(descriptor.id)) {
+      console.error("duplicate register contribution: ", descriptor.id);
+      return;
+    }
+    const staticArguments = descriptor.staticArguments ?? [];
+    this._createInstance(descriptor, staticArguments);
+  }
+  _createInstance(descriptor, staticArguments) {
+    const instance = this._instantiationService.createInstance(descriptor.ctor, ...staticArguments);
+    this._instances.set(descriptor.id, instance);
+  }
+};
+ExtensionService = __decorateClass([
+  __decorateParam(0, IInstantiationService)
+], ExtensionService);
+
+export { ExtensionService, IExtensionService, InstantiationPhase };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map