@zk-tech/bedrock 0.0.1

package/dist/platform/index.d.ts

@@ -0,0 +1,21 @@
+declare const isWindows: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
+declare const isWeb: boolean;
+declare const isIOS: boolean;
+declare const isAndroid: boolean;
+declare const isIPad: boolean;
+declare const isMobile: boolean;
+declare const isChrome: boolean;
+declare const isFirefox: boolean;
+declare const isSafari: boolean;
+/**
+ * 判断是否为 Arc 浏览器
+ * arc 浏览器判定方式比较奇特，无法通过 UA 判断
+ * https://stackoverflow.com/questions/76123232/can-javascript-detect-the-arc-browser
+ */
+declare function isArcBrowser(): boolean;
+/** ace2.0 不再提供这个方法  用于判断是否为浏览器环境*/
+declare function isBrowser(): boolean;
+
+export { isAndroid, isArcBrowser, isBrowser, isChrome, isFirefox, isIOS, isIPad, isLinux, isMac, isMobile, isSafari, isWeb, isWindows };

package/dist/platform/index.js

@@ -0,0 +1,48 @@
+// src/platform/index.ts
+var _isWindows = false;
+var _isMac = false;
+var _isLinux = false;
+var _isWeb = false;
+var _isIOS = false;
+var _isAndroid = false;
+var _isMobile = false;
+var _isIPad = false;
+var _isFirefox = false;
+var _isChrome = false;
+var _isSafari = false;
+var _userAgent;
+if (typeof navigator === "object") {
+  _userAgent = navigator.userAgent;
+  _isWindows = _userAgent.indexOf("Windows") >= 0;
+  _isIOS = (_userAgent.indexOf("Macintosh") >= 0 || _userAgent.indexOf("iPad") >= 0 || _userAgent.indexOf("iPhone") >= 0) && Boolean(navigator.maxTouchPoints) && navigator.maxTouchPoints > 0;
+  _isAndroid = _userAgent.indexOf("Android") >= 0;
+  _isLinux = _userAgent.indexOf("Linux") >= 0;
+  _isMobile = _userAgent.indexOf("Mobi") >= 0;
+  _isIPad = _userAgent.indexOf("iPad") >= 0;
+  _isMac = !_isMobile && _userAgent.indexOf("Macintosh") >= 0;
+  _isFirefox = /firefox/i.test(_userAgent);
+  _isChrome = /chrome/i.test(_userAgent);
+  _isSafari = /^((?!chrome|android).)*safari/i.test(_userAgent);
+  _isWeb = true;
+}
+var isWindows = _isWindows;
+var isMac = _isMac;
+var isLinux = _isLinux;
+var isWeb = _isWeb;
+var isIOS = _isIOS;
+var isAndroid = _isAndroid;
+var isIPad = _isIPad;
+var isMobile = _isMobile;
+var isChrome = _isChrome;
+var isFirefox = _isFirefox;
+var isSafari = _isSafari;
+function isArcBrowser() {
+  return getComputedStyle(document.documentElement).getPropertyValue("--arc-palette-title") ? true : false;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+}
+
+export { isAndroid, isArcBrowser, isBrowser, isChrome, isFirefox, isIOS, isIPad, isLinux, isMac, isMobile, isSafari, isWeb, isWindows };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/platform/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/index.ts"],"names":[],"mappings":";AACA,IAAI,UAAA,GAAa,KAAA;AACjB,IAAI,MAAA,GAAS,KAAA;AACb,IAAI,QAAA,GAAW,KAAA;AACf,IAAI,MAAA,GAAS,KAAA;AACb,IAAI,MAAA,GAAS,KAAA;AACb,IAAI,UAAA,GAAa,KAAA;AACjB,IAAI,SAAA,GAAY,KAAA;AAChB,IAAI,OAAA,GAAU,KAAA;AACd,IAAI,UAAA,GAAa,KAAA;AACjB,IAAI,SAAA,GAAY,KAAA;AAChB,IAAI,SAAA,GAAY,KAAA;AAChB,IAAI,UAAA;AAGJ,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,EAAA,UAAA,GAAa,SAAA,CAAU,SAAA;AACvB,EAAA,UAAA,GAAa,UAAA,CAAW,OAAA,CAAQ,SAAS,CAAA,IAAK,CAAA;AAC9C,EAAA,MAAA,GAAA,CACG,UAAA,CAAW,QAAQ,WAAW,CAAA,IAAK,KAClC,UAAA,CAAW,OAAA,CAAQ,MAAM,CAAA,IAAK,CAAA,IAC9B,WAAW,OAAA,CAAQ,QAAQ,KAAK,CAAA,KAClC,OAAA,CAAQ,UAAU,cAAc,CAAA,IAChC,UAAU,cAAA,GAAiB,CAAA;AAC7B,EAAA,UAAA,GAAa,UAAA,CAAW,OAAA,CAAQ,SAAS,CAAA,IAAK,CAAA;AAC9C,EAAA,QAAA,GAAW,UAAA,CAAW,OAAA,CAAQ,OAAO,CAAA,IAAK,CAAA;AAC1C,EAAA,SAAA,GAAY,UAAA,CAAW,OAAA,CAAQ,MAAM,CAAA,IAAK,CAAA;AAC1C,EAAA,OAAA,GAAU,UAAA,CAAW,OAAA,CAAQ,MAAM,CAAA,IAAK,CAAA;AACxC,EAAA,MAAA,GAAS,CAAC,SAAA,IAAa,UAAA,CAAW,OAAA,CAAQ,WAAW,CAAA,IAAK,CAAA;AAC1D,EAAA,UAAA,GAAa,UAAA,CAAW,KAAK,UAAU,CAAA;AACvC,EAAA,SAAA,GAAY,SAAA,CAAU,KAAK,UAAU,CAAA;AACrC,EAAA,SAAA,GAAY,gCAAA,CAAiC,KAAK,UAAU,CAAA;AAC5D,EAAA,MAAA,GAAS,IAAA;AACX;AAEO,IAAM,SAAA,GAAY;AAClB,IAAM,KAAA,GAAQ;AACd,IAAM,OAAA,GAAU;AAChB,IAAM,KAAA,GAAQ;AACd,IAAM,KAAA,GAAQ;AACd,IAAM,SAAA,GAAY;AAClB,IAAM,MAAA,GAAS;AACf,IAAM,QAAA,GAAW;AACjB,IAAM,QAAA,GAAW;AACjB,IAAM,SAAA,GAAY;AAClB,IAAM,QAAA,GAAW;AAOjB,SAAS,YAAA,GAAwB;AACtC,EAAA,OAAO,iBAAiB,QAAA,CAAS,eAAe,EAAE,gBAAA,CAAiB,qBAAqB,IAAI,IAAA,GAAO,KAAA;AACrG;AAGO,SAAS,SAAA,GAAqB;AACnC,EAAA,OACE,OAAO,MAAA,KAAW,WAAA,IAClB,OAAO,MAAA,CAAO,aAAa,WAAA,IAC3B,OAAO,MAAA,CAAO,QAAA,CAAS,aAAA,KAAkB,WAAA;AAE7C","file":"index.js","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\nlet _isWindows = false;\nlet _isMac = false;\nlet _isLinux = false;\nlet _isWeb = false;\nlet _isIOS = false;\nlet _isAndroid = false;\nlet _isMobile = false;\nlet _isIPad = false;\nlet _isFirefox = false;\nlet _isChrome = false;\nlet _isSafari = false;\nlet _userAgent: string | undefined;\n\n// Web environment\nif (typeof navigator === 'object') {\n  _userAgent = navigator.userAgent;\n  _isWindows = _userAgent.indexOf('Windows') >= 0;\n  _isIOS =\n    (_userAgent.indexOf('Macintosh') >= 0 ||\n      _userAgent.indexOf('iPad') >= 0 ||\n      _userAgent.indexOf('iPhone') >= 0) &&\n    Boolean(navigator.maxTouchPoints) &&\n    navigator.maxTouchPoints > 0;\n  _isAndroid = _userAgent.indexOf('Android') >= 0;\n  _isLinux = _userAgent.indexOf('Linux') >= 0;\n  _isMobile = _userAgent.indexOf('Mobi') >= 0;\n  _isIPad = _userAgent.indexOf('iPad') >= 0;\n  _isMac = !_isMobile && _userAgent.indexOf('Macintosh') >= 0;\n  _isFirefox = /firefox/i.test(_userAgent);\n  _isChrome = /chrome/i.test(_userAgent);\n  _isSafari = /^((?!chrome|android).)*safari/i.test(_userAgent);\n  _isWeb = true;\n}\n\nexport const isWindows = _isWindows;\nexport const isMac = _isMac;\nexport const isLinux = _isLinux;\nexport const isWeb = _isWeb;\nexport const isIOS = _isIOS;\nexport const isAndroid = _isAndroid;\nexport const isIPad = _isIPad;\nexport const isMobile = _isMobile;\nexport const isChrome = _isChrome;\nexport const isFirefox = _isFirefox;\nexport const isSafari = _isSafari;\n\n/**\n * 判断是否为 Arc 浏览器\n * arc 浏览器判定方式比较奇特，无法通过 UA 判断\n * https://stackoverflow.com/questions/76123232/can-javascript-detect-the-arc-browser\n */\nexport function isArcBrowser(): boolean {\n  return getComputedStyle(document.documentElement).getPropertyValue('--arc-palette-title') ? true : false;\n};\n\n/** ace2.0 不再提供这个方法  用于判断是否为浏览器环境*/\nexport function isBrowser(): boolean {\n  return (\n    typeof window !== 'undefined' &&\n    typeof window.document !== 'undefined' &&\n    typeof window.document.createElement !== 'undefined'\n  );\n}\n"]}

package/dist/promise/index.cjs

@@ -0,0 +1,639 @@
+'use strict';
+
+// src/error/error-t.ts
+var lvErrorRefSymbol = /* @__PURE__ */ Symbol("lvErrorRef");
+function findJsError(error) {
+  let obj = error;
+  while (obj) {
+    if (obj instanceof Error) {
+      return obj;
+    }
+    obj = obj.cause;
+  }
+  return new Error(error.toString());
+}
+function makeOk() {
+  return {
+    ok: true,
+    value: null,
+    pair() {
+      return [null, null];
+    },
+    code: 0,
+    msg: "",
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+}
+function makeOkWith(value) {
+  return {
+    ok: true,
+    value,
+    pair() {
+      return [null, value];
+    },
+    code: 0,
+    msg: "",
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+}
+function printCause(cause) {
+  if (cause === void 0) {
+    return "";
+  } else if (cause instanceof Error) {
+    return `
+caused by [jsError]${cause.name}-${cause.message}`;
+  } else {
+    return `
+caused by [${cause.code}]${cause.msg}${cause.ok ? "" : printCause(cause.cause)}`;
+  }
+}
+function internalMakeError(code, msg, cause, errorInfo) {
+  const errorRef = {
+    ok: false,
+    code,
+    msg,
+    cause,
+    errorInfo,
+    toString() {
+      return `[${code}]${msg}.${cause ? printCause(cause) : ""}`;
+    },
+    pair() {
+      return [errorRef, null];
+    },
+    stack: cause instanceof Error ? cause.stack : void 0,
+    findJsError: () => findJsError(errorRef),
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+  return errorRef;
+}
+function makeError(code, msg, errorInfo) {
+  return internalMakeError(code, msg, void 0, errorInfo);
+}
+function makeErrorBy(code, msg, cause, errorInfo) {
+  return internalMakeError(code, msg, cause, errorInfo);
+}
+function isLvErrorRef(val) {
+  return typeof val === "object" && val !== null && lvErrorRefSymbol in val;
+}
+
+// src/error/error-const.ts
+function lvErrorConst(code, msg) {
+  return (rewrite) => {
+    if (!rewrite) {
+      return makeError(code, msg);
+    }
+    if (typeof rewrite === "string") {
+      return makeError(code, rewrite);
+    }
+    return makeErrorBy(code, rewrite.message, rewrite);
+  };
+}
+
+// src/error/error-code.ts
+var cancelledError = lvErrorConst(1 /* Cancelled */, "operation(s) cancelled.");
+var timeoutError = lvErrorConst(2 /* TimedOut */, "operation(s) timed out.");
+
+// src/dispose/dispose-base.ts
+var EmptyDispose = Object.freeze({ dispose() {
+} });
+
+// 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;
+}
+
+// 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/async/cancellation.ts
+var shortcutEvent = Object.freeze(function(callback, context) {
+  const handle = setTimeout(callback.bind(context), 0);
+  return {
+    dispose() {
+      clearTimeout(handle);
+    }
+  };
+});
+var MutableToken = class {
+  constructor() {
+    // 是否已经取消该异步调用
+    this._isCancelled = false;
+    this._emitter = null;
+  }
+  get reason() {
+    return this._reason;
+  }
+  // 获取当前是否已经取消该异步调用
+  get isCancellationRequested() {
+    return this._isCancelled;
+  }
+  // 外界可以监听异步取消发起
+  get onCancellationRequested() {
+    if (this._isCancelled) {
+      return shortcutEvent;
+    }
+    if (!this._emitter) {
+      this._emitter = new Emitter();
+    }
+    return this._emitter.event;
+  }
+  cancel(reason) {
+    if (!this._isCancelled) {
+      this._reason = reason;
+      this._isCancelled = true;
+      if (this._emitter) {
+        this._emitter.fire();
+        this.dispose();
+      }
+    }
+  }
+  dispose() {
+    if (this._emitter) {
+      this._emitter.dispose();
+      this._emitter = null;
+    }
+  }
+};
+var CancellationToken = class {
+};
+CancellationToken.None = Object.freeze({
+  isCancellationRequested: false,
+  onCancellationRequested: () => EmptyDispose
+});
+CancellationToken.Cancelled = Object.freeze({
+  isCancellationRequested: true,
+  onCancellationRequested: shortcutEvent
+});
+CancellationToken.Make = (reason) => {
+  return Object.freeze({
+    isCancellationRequested: true,
+    onCancellationRequested: shortcutEvent,
+    reason
+  });
+};
+var CancellationTokenSource = class {
+  constructor(parent) {
+    // 真正的token
+    this._token = void 0;
+    // 可能存在父级CancellationTokenSource
+    this._parentListener = void 0;
+    // 为了支持signal场景，所以在需要时会初始化浏览器提供的abortController原生结构
+    this._abortController = void 0;
+    this._parentListener = parent?.onCancellationRequested(this.cancel, this);
+  }
+  /**
+   * 传统的cancellation用法
+   */
+  get token() {
+    if (!this._token) {
+      this._token = new MutableToken();
+    }
+    return this._token;
+  }
+  /**
+   * 对齐浏览器提供的abortSignal，支持给fetch、axios等传参使用
+   */
+  get signal() {
+    if (this._abortController) {
+      return this._abortController.signal;
+    }
+    this._abortController = new AbortController();
+    if (this._token?.isCancellationRequested) {
+      this._abortController.abort();
+    }
+    return this._abortController.signal;
+  }
+  cancel(reason) {
+    if (!this._token) {
+      this._token = reason === void 0 ? CancellationToken.Cancelled : CancellationToken.Make(reason);
+    } else if (this._token instanceof MutableToken) {
+      this._token.cancel(reason);
+    }
+    if (this._abortController) {
+      this._abortController.abort(reason);
+    }
+  }
+  dispose(cancel = false) {
+    if (cancel) {
+      this.cancel();
+    }
+    this._parentListener?.dispose();
+    if (!this._token) {
+      this._token = CancellationToken.None;
+    } else if (this._token instanceof MutableToken) {
+      this._token.dispose();
+    }
+  }
+};
+
+// src/promise/promise.ts
+function makeCancelablePromise(callback) {
+  const source = new CancellationTokenSource();
+  const thenable = callback(source.token);
+  const promise = new Promise((resolve, reject) => {
+    const subscription = source.token.onCancellationRequested(() => {
+      subscription.dispose();
+      source.dispose();
+      resolve(cancelledError());
+    });
+    Promise.resolve(thenable).then(
+      (value) => {
+        subscription.dispose();
+        source.dispose();
+        if (isLvErrorRef(value)) {
+          resolve(value);
+        } else {
+          resolve(makeOkWith(value));
+        }
+      },
+      (err) => {
+        subscription.dispose();
+        source.dispose();
+        reject(err);
+      }
+    );
+  });
+  return new class {
+    cancel() {
+      source.cancel();
+    }
+    then(resolve, reject) {
+      return promise.then(resolve, reject);
+    }
+    catch(reject) {
+      return this.then(void 0, reject);
+    }
+    finally(onfinally) {
+      return promise.finally(onfinally);
+    }
+  }();
+}
+function parallelPromise(promiseList) {
+  if (promiseList.length === 0) {
+    return Promise.resolve(makeOk());
+  }
+  let todo = promiseList.length;
+  const finish = () => {
+    todo = -1;
+    for (const promise of promiseList) {
+      promise.cancel?.();
+    }
+  };
+  return new Promise((resolve, reject) => {
+    for (const promise of promiseList) {
+      promise.then((res) => {
+        if (isLvErrorRef(res) && !res.ok) {
+          finish();
+          resolve(res);
+          return;
+        }
+        todo--;
+        if (todo === 0) {
+          resolve(makeOk());
+        }
+      }).catch((err) => {
+        finish();
+        reject(err);
+      });
+    }
+  });
+}
+function makePromiseWithTimeout(callback, timeout, defaultValue) {
+  const cancellable = makeCancelablePromise(callback);
+  const timer = setTimeout(() => {
+    cancellable.cancel();
+  }, timeout);
+  return cancellable.then((res) => {
+    clearTimeout(timer);
+    if (res.ok) {
+      return res;
+    }
+    if (res.code === 1 /* Cancelled */) {
+      if (defaultValue !== void 0) {
+        return makeOkWith(defaultValue);
+      }
+      return timeoutError();
+    } else {
+      return res;
+    }
+  });
+}
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+function waitForAbortSignal(signal) {
+  const { promise, reject } = defer();
+  if (signal.aborted) {
+    reject(signal.reason);
+  }
+  const handleAbort = () => {
+    reject(signal.reason);
+    signal.removeEventListener("abort", handleAbort);
+  };
+  signal.addEventListener("abort", handleAbort);
+  return promise;
+}
+
+exports.defer = defer;
+exports.makeCancelablePromise = makeCancelablePromise;
+exports.makePromiseWithTimeout = makePromiseWithTimeout;
+exports.parallelPromise = parallelPromise;
+exports.waitForAbortSignal = waitForAbortSignal;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map