monaco-editor 0.53.0 → 0.54.0-dev-20250910

package/dev/vs/assets/{css.worker.4040859e.js → css.worker.be279320.js}

@@ -11983,6 +11983,9 @@ var __publicField = (obj, key, value) => {
       });
     }
     complete(value) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.completeCallback(value);
         this.outcome = { outcome: 0, value };
@@ -11990,6 +11993,9 @@ var __publicField = (obj, key, value) => {
       });
     }
     error(err) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.errorCallback(err);
         this.outcome = { outcome: 1, value: err };
@@ -12027,151 +12033,6 @@ var __publicField = (obj, key, value) => {
     }
     Promises2.withAsyncBody = withAsyncBody;
   })(Promises || (Promises = {}));
-  const _AsyncIterableObject = class {
-    static fromArray(items) {
-      return new _AsyncIterableObject((writer) => {
-        writer.emitMany(items);
-      });
-    }
-    static fromPromise(promise) {
-      return new _AsyncIterableObject(async (emitter) => {
-        emitter.emitMany(await promise);
-      });
-    }
-    static fromPromisesResolveOrder(promises) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
-      });
-    }
-    static merge(iterables) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(iterables.map(async (iterable) => {
-          for await (const item of iterable) {
-            emitter.emitOne(item);
-          }
-        }));
-      });
-    }
-    constructor(executor, onReturn) {
-      this._state = 0;
-      this._results = [];
-      this._error = null;
-      this._onReturn = onReturn;
-      this._onStateChanged = new Emitter();
-      queueMicrotask(async () => {
-        const writer = {
-          emitOne: (item) => this.emitOne(item),
-          emitMany: (items) => this.emitMany(items),
-          reject: (error) => this.reject(error)
-        };
-        try {
-          await Promise.resolve(executor(writer));
-          this.resolve();
-        } catch (err) {
-          this.reject(err);
-        } finally {
-          writer.emitOne = void 0;
-          writer.emitMany = void 0;
-          writer.reject = void 0;
-        }
-      });
-    }
-    [Symbol.asyncIterator]() {
-      let i = 0;
-      return {
-        next: async () => {
-          do {
-            if (this._state === 2) {
-              throw this._error;
-            }
-            if (i < this._results.length) {
-              return { done: false, value: this._results[i++] };
-            }
-            if (this._state === 1) {
-              return { done: true, value: void 0 };
-            }
-            await Event.toPromise(this._onStateChanged.event);
-          } while (true);
-        },
-        return: async () => {
-          var _a3;
-          (_a3 = this._onReturn) == null ? void 0 : _a3.call(this);
-          return { done: true, value: void 0 };
-        }
-      };
-    }
-    static map(iterable, mapFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          emitter.emitOne(mapFn(item));
-        }
-      });
-    }
-    map(mapFn) {
-      return _AsyncIterableObject.map(this, mapFn);
-    }
-    static filter(iterable, filterFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          if (filterFn(item)) {
-            emitter.emitOne(item);
-          }
-        }
-      });
-    }
-    filter(filterFn) {
-      return _AsyncIterableObject.filter(this, filterFn);
-    }
-    static coalesce(iterable) {
-      return _AsyncIterableObject.filter(iterable, (item) => !!item);
-    }
-    coalesce() {
-      return _AsyncIterableObject.coalesce(this);
-    }
-    static async toPromise(iterable) {
-      const result = [];
-      for await (const item of iterable) {
-        result.push(item);
-      }
-      return result;
-    }
-    toPromise() {
-      return _AsyncIterableObject.toPromise(this);
-    }
-    emitOne(value) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results.push(value);
-      this._onStateChanged.fire();
-    }
-    emitMany(values2) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results = this._results.concat(values2);
-      this._onStateChanged.fire();
-    }
-    resolve() {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 1;
-      this._onStateChanged.fire();
-    }
-    reject(error) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 2;
-      this._error = error;
-      this._onStateChanged.fire();
-    }
-  };
-  let AsyncIterableObject = _AsyncIterableObject;
-  (() => {
-    _AsyncIterableObject.EMPTY = _AsyncIterableObject.fromArray([]);
-  })();
   class ProducerConsumer {
     constructor() {
       this._unsatisfiedConsumers = [];

package/dev/vs/assets/{editor.worker.50c051c0.js → editor.worker.9f8d1c9d.js}

@@ -11977,6 +11977,9 @@
       });
     }
     complete(value) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.completeCallback(value);
         this.outcome = { outcome: 0, value };
@@ -11984,6 +11987,9 @@
       });
     }
     error(err) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.errorCallback(err);
         this.outcome = { outcome: 1, value: err };
@@ -12021,151 +12027,6 @@
     }
     Promises2.withAsyncBody = withAsyncBody;
   })(Promises || (Promises = {}));
-  const _AsyncIterableObject = class {
-    static fromArray(items) {
-      return new _AsyncIterableObject((writer) => {
-        writer.emitMany(items);
-      });
-    }
-    static fromPromise(promise) {
-      return new _AsyncIterableObject(async (emitter) => {
-        emitter.emitMany(await promise);
-      });
-    }
-    static fromPromisesResolveOrder(promises) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
-      });
-    }
-    static merge(iterables) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(iterables.map(async (iterable) => {
-          for await (const item of iterable) {
-            emitter.emitOne(item);
-          }
-        }));
-      });
-    }
-    constructor(executor, onReturn) {
-      this._state = 0;
-      this._results = [];
-      this._error = null;
-      this._onReturn = onReturn;
-      this._onStateChanged = new Emitter();
-      queueMicrotask(async () => {
-        const writer = {
-          emitOne: (item) => this.emitOne(item),
-          emitMany: (items) => this.emitMany(items),
-          reject: (error) => this.reject(error)
-        };
-        try {
-          await Promise.resolve(executor(writer));
-          this.resolve();
-        } catch (err) {
-          this.reject(err);
-        } finally {
-          writer.emitOne = void 0;
-          writer.emitMany = void 0;
-          writer.reject = void 0;
-        }
-      });
-    }
-    [Symbol.asyncIterator]() {
-      let i = 0;
-      return {
-        next: async () => {
-          do {
-            if (this._state === 2) {
-              throw this._error;
-            }
-            if (i < this._results.length) {
-              return { done: false, value: this._results[i++] };
-            }
-            if (this._state === 1) {
-              return { done: true, value: void 0 };
-            }
-            await Event.toPromise(this._onStateChanged.event);
-          } while (true);
-        },
-        return: async () => {
-          var _a3;
-          (_a3 = this._onReturn) == null ? void 0 : _a3.call(this);
-          return { done: true, value: void 0 };
-        }
-      };
-    }
-    static map(iterable, mapFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          emitter.emitOne(mapFn(item));
-        }
-      });
-    }
-    map(mapFn) {
-      return _AsyncIterableObject.map(this, mapFn);
-    }
-    static filter(iterable, filterFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          if (filterFn(item)) {
-            emitter.emitOne(item);
-          }
-        }
-      });
-    }
-    filter(filterFn) {
-      return _AsyncIterableObject.filter(this, filterFn);
-    }
-    static coalesce(iterable) {
-      return _AsyncIterableObject.filter(iterable, (item) => !!item);
-    }
-    coalesce() {
-      return _AsyncIterableObject.coalesce(this);
-    }
-    static async toPromise(iterable) {
-      const result = [];
-      for await (const item of iterable) {
-        result.push(item);
-      }
-      return result;
-    }
-    toPromise() {
-      return _AsyncIterableObject.toPromise(this);
-    }
-    emitOne(value) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results.push(value);
-      this._onStateChanged.fire();
-    }
-    emitMany(values) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results = this._results.concat(values);
-      this._onStateChanged.fire();
-    }
-    resolve() {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 1;
-      this._onStateChanged.fire();
-    }
-    reject(error) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 2;
-      this._error = error;
-      this._onStateChanged.fire();
-    }
-  };
-  let AsyncIterableObject = _AsyncIterableObject;
-  (() => {
-    _AsyncIterableObject.EMPTY = _AsyncIterableObject.fromArray([]);
-  })();
   class ProducerConsumer {
     constructor() {
       this._unsatisfiedConsumers = [];

package/dev/vs/assets/{html.worker.1a3caaf3.js → html.worker.70c7fa17.js}

@@ -11983,6 +11983,9 @@ var __publicField = (obj, key, value) => {
       });
     }
     complete(value) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.completeCallback(value);
         this.outcome = { outcome: 0, value };
@@ -11990,6 +11993,9 @@ var __publicField = (obj, key, value) => {
       });
     }
     error(err) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.errorCallback(err);
         this.outcome = { outcome: 1, value: err };
@@ -12027,151 +12033,6 @@ var __publicField = (obj, key, value) => {
     }
     Promises2.withAsyncBody = withAsyncBody;
   })(Promises || (Promises = {}));
-  const _AsyncIterableObject = class {
-    static fromArray(items) {
-      return new _AsyncIterableObject((writer) => {
-        writer.emitMany(items);
-      });
-    }
-    static fromPromise(promise) {
-      return new _AsyncIterableObject(async (emitter) => {
-        emitter.emitMany(await promise);
-      });
-    }
-    static fromPromisesResolveOrder(promises) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
-      });
-    }
-    static merge(iterables) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(iterables.map(async (iterable) => {
-          for await (const item of iterable) {
-            emitter.emitOne(item);
-          }
-        }));
-      });
-    }
-    constructor(executor, onReturn) {
-      this._state = 0;
-      this._results = [];
-      this._error = null;
-      this._onReturn = onReturn;
-      this._onStateChanged = new Emitter();
-      queueMicrotask(async () => {
-        const writer = {
-          emitOne: (item) => this.emitOne(item),
-          emitMany: (items) => this.emitMany(items),
-          reject: (error) => this.reject(error)
-        };
-        try {
-          await Promise.resolve(executor(writer));
-          this.resolve();
-        } catch (err) {
-          this.reject(err);
-        } finally {
-          writer.emitOne = void 0;
-          writer.emitMany = void 0;
-          writer.reject = void 0;
-        }
-      });
-    }
-    [Symbol.asyncIterator]() {
-      let i = 0;
-      return {
-        next: async () => {
-          do {
-            if (this._state === 2) {
-              throw this._error;
-            }
-            if (i < this._results.length) {
-              return { done: false, value: this._results[i++] };
-            }
-            if (this._state === 1) {
-              return { done: true, value: void 0 };
-            }
-            await Event.toPromise(this._onStateChanged.event);
-          } while (true);
-        },
-        return: async () => {
-          var _a3;
-          (_a3 = this._onReturn) == null ? void 0 : _a3.call(this);
-          return { done: true, value: void 0 };
-        }
-      };
-    }
-    static map(iterable, mapFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          emitter.emitOne(mapFn(item));
-        }
-      });
-    }
-    map(mapFn) {
-      return _AsyncIterableObject.map(this, mapFn);
-    }
-    static filter(iterable, filterFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          if (filterFn(item)) {
-            emitter.emitOne(item);
-          }
-        }
-      });
-    }
-    filter(filterFn) {
-      return _AsyncIterableObject.filter(this, filterFn);
-    }
-    static coalesce(iterable) {
-      return _AsyncIterableObject.filter(iterable, (item) => !!item);
-    }
-    coalesce() {
-      return _AsyncIterableObject.coalesce(this);
-    }
-    static async toPromise(iterable) {
-      const result = [];
-      for await (const item of iterable) {
-        result.push(item);
-      }
-      return result;
-    }
-    toPromise() {
-      return _AsyncIterableObject.toPromise(this);
-    }
-    emitOne(value) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results.push(value);
-      this._onStateChanged.fire();
-    }
-    emitMany(values) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results = this._results.concat(values);
-      this._onStateChanged.fire();
-    }
-    resolve() {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 1;
-      this._onStateChanged.fire();
-    }
-    reject(error) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 2;
-      this._error = error;
-      this._onStateChanged.fire();
-    }
-  };
-  let AsyncIterableObject = _AsyncIterableObject;
-  (() => {
-    _AsyncIterableObject.EMPTY = _AsyncIterableObject.fromArray([]);
-  })();
   class ProducerConsumer {
     constructor() {
       this._unsatisfiedConsumers = [];

package/dev/vs/assets/{json.worker.32db31cb.js → json.worker.1126f7cb.js}

@@ -11983,6 +11983,9 @@ var __publicField = (obj, key, value) => {
       });
     }
     complete(value) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.completeCallback(value);
         this.outcome = { outcome: 0, value };
@@ -11990,6 +11993,9 @@ var __publicField = (obj, key, value) => {
       });
     }
     error(err) {
+      if (this.isSettled) {
+        return Promise.resolve();
+      }
       return new Promise((resolve) => {
         this.errorCallback(err);
         this.outcome = { outcome: 1, value: err };
@@ -12027,151 +12033,6 @@ var __publicField = (obj, key, value) => {
     }
     Promises2.withAsyncBody = withAsyncBody;
   })(Promises || (Promises = {}));
-  const _AsyncIterableObject = class {
-    static fromArray(items) {
-      return new _AsyncIterableObject((writer) => {
-        writer.emitMany(items);
-      });
-    }
-    static fromPromise(promise) {
-      return new _AsyncIterableObject(async (emitter) => {
-        emitter.emitMany(await promise);
-      });
-    }
-    static fromPromisesResolveOrder(promises) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
-      });
-    }
-    static merge(iterables) {
-      return new _AsyncIterableObject(async (emitter) => {
-        await Promise.all(iterables.map(async (iterable) => {
-          for await (const item of iterable) {
-            emitter.emitOne(item);
-          }
-        }));
-      });
-    }
-    constructor(executor, onReturn) {
-      this._state = 0;
-      this._results = [];
-      this._error = null;
-      this._onReturn = onReturn;
-      this._onStateChanged = new Emitter();
-      queueMicrotask(async () => {
-        const writer = {
-          emitOne: (item) => this.emitOne(item),
-          emitMany: (items) => this.emitMany(items),
-          reject: (error) => this.reject(error)
-        };
-        try {
-          await Promise.resolve(executor(writer));
-          this.resolve();
-        } catch (err) {
-          this.reject(err);
-        } finally {
-          writer.emitOne = void 0;
-          writer.emitMany = void 0;
-          writer.reject = void 0;
-        }
-      });
-    }
-    [Symbol.asyncIterator]() {
-      let i = 0;
-      return {
-        next: async () => {
-          do {
-            if (this._state === 2) {
-              throw this._error;
-            }
-            if (i < this._results.length) {
-              return { done: false, value: this._results[i++] };
-            }
-            if (this._state === 1) {
-              return { done: true, value: void 0 };
-            }
-            await Event.toPromise(this._onStateChanged.event);
-          } while (true);
-        },
-        return: async () => {
-          var _a3;
-          (_a3 = this._onReturn) == null ? void 0 : _a3.call(this);
-          return { done: true, value: void 0 };
-        }
-      };
-    }
-    static map(iterable, mapFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          emitter.emitOne(mapFn(item));
-        }
-      });
-    }
-    map(mapFn) {
-      return _AsyncIterableObject.map(this, mapFn);
-    }
-    static filter(iterable, filterFn) {
-      return new _AsyncIterableObject(async (emitter) => {
-        for await (const item of iterable) {
-          if (filterFn(item)) {
-            emitter.emitOne(item);
-          }
-        }
-      });
-    }
-    filter(filterFn) {
-      return _AsyncIterableObject.filter(this, filterFn);
-    }
-    static coalesce(iterable) {
-      return _AsyncIterableObject.filter(iterable, (item) => !!item);
-    }
-    coalesce() {
-      return _AsyncIterableObject.coalesce(this);
-    }
-    static async toPromise(iterable) {
-      const result = [];
-      for await (const item of iterable) {
-        result.push(item);
-      }
-      return result;
-    }
-    toPromise() {
-      return _AsyncIterableObject.toPromise(this);
-    }
-    emitOne(value) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results.push(value);
-      this._onStateChanged.fire();
-    }
-    emitMany(values) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._results = this._results.concat(values);
-      this._onStateChanged.fire();
-    }
-    resolve() {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 1;
-      this._onStateChanged.fire();
-    }
-    reject(error) {
-      if (this._state !== 0) {
-        return;
-      }
-      this._state = 2;
-      this._error = error;
-      this._onStateChanged.fire();
-    }
-  };
-  let AsyncIterableObject = _AsyncIterableObject;
-  (() => {
-    _AsyncIterableObject.EMPTY = _AsyncIterableObject.fromArray([]);
-  })();
   class ProducerConsumer {
     constructor() {
       this._unsatisfiedConsumers = [];