@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@whatwg-node/disposablestack/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../node_modules/@whatwg-node/disposablestack/esm/utils.js"],"sourcesContent":["import { DisposableSymbols } from './symbols.js';\nexport function isSyncDisposable(obj) {\n    return obj?.[DisposableSymbols.dispose] != null;\n}\nexport function isAsyncDisposable(obj) {\n    return obj?.[DisposableSymbols.asyncDispose] != null;\n}\n"],"names":[],"mappings":";AACO,SAAS,iBAAiB,KAAK;AAClC,SAAO,MAAM,kBAAkB,OAAO,KAAK;AAC/C;AACO,SAAS,kBAAkB,KAAK;AACnC,SAAO,MAAM,kBAAkB,YAAY,KAAK;AACpD;","x_google_ignoreList":[0]}

package/dist/node_modules/@whatwg-node/fetch/dist/global-ponyfill.js

@@ -0,0 +1,33 @@
+import { __exports as globalPonyfill } from "../../../../_virtual/global-ponyfill2.js";
+var hasRequiredGlobalPonyfill;
+function requireGlobalPonyfill() {
+  if (hasRequiredGlobalPonyfill) return globalPonyfill;
+  hasRequiredGlobalPonyfill = 1;
+  globalPonyfill.fetch = globalThis.fetch;
+  globalPonyfill.Headers = globalThis.Headers;
+  globalPonyfill.Request = globalThis.Request;
+  globalPonyfill.Response = globalThis.Response;
+  globalPonyfill.FormData = globalThis.FormData;
+  globalPonyfill.ReadableStream = globalThis.ReadableStream;
+  globalPonyfill.WritableStream = globalThis.WritableStream;
+  globalPonyfill.TransformStream = globalThis.TransformStream;
+  globalPonyfill.CompressionStream = globalThis.CompressionStream;
+  globalPonyfill.DecompressionStream = globalThis.DecompressionStream;
+  globalPonyfill.TextDecoderStream = globalThis.TextDecoderStream;
+  globalPonyfill.TextEncoderStream = globalThis.TextEncoderStream;
+  globalPonyfill.Blob = globalThis.Blob;
+  globalPonyfill.File = globalThis.File;
+  globalPonyfill.crypto = globalThis.crypto;
+  globalPonyfill.btoa = globalThis.btoa;
+  globalPonyfill.TextEncoder = globalThis.TextEncoder;
+  globalPonyfill.TextDecoder = globalThis.TextDecoder;
+  globalPonyfill.URLPattern = globalThis.URLPattern;
+  globalPonyfill.URL = globalThis.URL;
+  globalPonyfill.URLSearchParams = globalThis.URLSearchParams;
+  globalPonyfill.createFetch = () => globalThis;
+  return globalPonyfill;
+}
+export {
+  requireGlobalPonyfill as __require
+};
+//# sourceMappingURL=global-ponyfill.js.map

package/dist/node_modules/@whatwg-node/fetch/dist/global-ponyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-ponyfill.js","sources":["../../../../../node_modules/@whatwg-node/fetch/dist/global-ponyfill.js"],"sourcesContent":["module.exports.fetch = globalThis.fetch;\nmodule.exports.Headers = globalThis.Headers;\nmodule.exports.Request = globalThis.Request;\nmodule.exports.Response = globalThis.Response;\nmodule.exports.FormData = globalThis.FormData;\nmodule.exports.ReadableStream = globalThis.ReadableStream;\nmodule.exports.WritableStream = globalThis.WritableStream;\nmodule.exports.TransformStream = globalThis.TransformStream;\nmodule.exports.CompressionStream = globalThis.CompressionStream;\nmodule.exports.DecompressionStream = globalThis.DecompressionStream;\nmodule.exports.TextDecoderStream = globalThis.TextDecoderStream;\nmodule.exports.TextEncoderStream = globalThis.TextEncoderStream;\nmodule.exports.Blob = globalThis.Blob;\nmodule.exports.File = globalThis.File;\nmodule.exports.crypto = globalThis.crypto;\nmodule.exports.btoa = globalThis.btoa;\nmodule.exports.TextEncoder = globalThis.TextEncoder;\nmodule.exports.TextDecoder = globalThis.TextDecoder;\nmodule.exports.URLPattern = globalThis.URLPattern;\nmodule.exports.URL = globalThis.URL;\nmodule.exports.URLSearchParams = globalThis.URLSearchParams;\nmodule.exports.createFetch = () => globalThis;\n"],"names":[],"mappings":";;;;;AAAA,iBAAA,QAAuB,WAAW;AAClC,iBAAA,UAAyB,WAAW;AACpC,iBAAA,UAAyB,WAAW;AACpC,iBAAA,WAA0B,WAAW;AACrC,iBAAA,WAA0B,WAAW;AACrC,iBAAA,iBAAgC,WAAW;AAC3C,iBAAA,iBAAgC,WAAW;AAC3C,iBAAA,kBAAiC,WAAW;AAC5C,iBAAA,oBAAmC,WAAW;AAC9C,iBAAA,sBAAqC,WAAW;AAChD,iBAAA,oBAAmC,WAAW;AAC9C,iBAAA,oBAAmC,WAAW;AAC9C,iBAAA,OAAsB,WAAW;AACjC,iBAAA,OAAsB,WAAW;AACjC,iBAAA,SAAwB,WAAW;AACnC,iBAAA,OAAsB,WAAW;AACjC,iBAAA,cAA6B,WAAW;AACxC,iBAAA,cAA6B,WAAW;AACxC,iBAAA,aAA4B,WAAW;AACvC,iBAAA,MAAqB,WAAW;AAChC,iBAAA,kBAAiC,WAAW;AAC5C,iBAAA,cAA6B,MAAM;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@whatwg-node/promise-helpers/esm/index.js

@@ -0,0 +1,241 @@
+const kFakePromise = Symbol.for("@whatwg-node/promise-helpers/FakePromise");
+function isPromise(value) {
+  return value?.then != null;
+}
+function isActualPromise(value) {
+  const maybePromise = value;
+  return maybePromise && maybePromise.then && maybePromise.catch && maybePromise.finally;
+}
+function handleMaybePromise(inputFactory, outputSuccessFactory, outputErrorFactory, finallyFactory) {
+  let result$ = fakePromise().then(inputFactory).then(outputSuccessFactory, outputErrorFactory);
+  return unfakePromise(result$);
+}
+function fakePromise(value) {
+  if (value && isActualPromise(value)) {
+    return value;
+  }
+  if (isPromise(value)) {
+    return {
+      then: (resolve, reject) => fakePromise(value.then(resolve, reject)),
+      catch: (reject) => fakePromise(value.then((res) => res, reject)),
+      finally: (cb) => fakePromise(cb ? promiseLikeFinally(value, cb) : value),
+      [Symbol.toStringTag]: "Promise"
+    };
+  }
+  return {
+    then(resolve) {
+      if (resolve) {
+        try {
+          return fakePromise(resolve(value));
+        } catch (err) {
+          return fakeRejectPromise(err);
+        }
+      }
+      return this;
+    },
+    catch() {
+      return this;
+    },
+    finally(cb) {
+      if (cb) {
+        try {
+          return fakePromise(cb()).then(() => value, () => value);
+        } catch (err) {
+          return fakeRejectPromise(err);
+        }
+      }
+      return this;
+    },
+    [Symbol.toStringTag]: "Promise",
+    __fakePromiseValue: value,
+    [kFakePromise]: "resolved"
+  };
+}
+function createDeferredPromise() {
+  if (Promise.withResolvers) {
+    return Promise.withResolvers();
+  }
+  let resolveFn;
+  let rejectFn;
+  const promise = new Promise(function deferredPromiseExecutor(resolve, reject) {
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+  return {
+    promise,
+    get resolve() {
+      return resolveFn;
+    },
+    get reject() {
+      return rejectFn;
+    }
+  };
+}
+function iterateAsync(iterable, callback, results) {
+  if (iterable?.length === 0) {
+    return;
+  }
+  const iterator = iterable[Symbol.iterator]();
+  let index = 0;
+  function iterate() {
+    const { done: endOfIterator, value } = iterator.next();
+    if (endOfIterator) {
+      return;
+    }
+    let endedEarly = false;
+    function endEarly() {
+      endedEarly = true;
+    }
+    return handleMaybePromise(function handleCallback() {
+      return callback(value, endEarly, index++);
+    }, function handleCallbackResult(result) {
+      if (result) {
+        results?.push(result);
+      }
+      if (endedEarly) {
+        return;
+      }
+      return iterate();
+    });
+  }
+  return iterate();
+}
+function fakeRejectPromise(error) {
+  return {
+    then(_resolve, reject) {
+      if (reject) {
+        try {
+          return fakePromise(reject(error));
+        } catch (err) {
+          return fakeRejectPromise(err);
+        }
+      }
+      return this;
+    },
+    catch(reject) {
+      if (reject) {
+        try {
+          return fakePromise(reject(error));
+        } catch (err) {
+          return fakeRejectPromise(err);
+        }
+      }
+      return this;
+    },
+    finally(cb) {
+      if (cb) {
+        try {
+          cb();
+        } catch (err) {
+          return fakeRejectPromise(err);
+        }
+      }
+      return this;
+    },
+    __fakeRejectError: error,
+    [Symbol.toStringTag]: "Promise",
+    [kFakePromise]: "rejected"
+  };
+}
+function mapAsyncIterator(iterator, onNext, onError, onEnd) {
+  if (Symbol.asyncIterator in iterator) {
+    iterator = iterator[Symbol.asyncIterator]();
+  }
+  let $return;
+  let abruptClose;
+  if (typeof iterator.return === "function") {
+    $return = iterator.return;
+    abruptClose = (error) => {
+      const rethrow = () => {
+        throw error;
+      };
+      return $return.call(iterator).then(rethrow, rethrow);
+    };
+  }
+  function mapResult(result) {
+    if (result.done) {
+      return result;
+    }
+    return handleMaybePromise(() => result.value, (value) => handleMaybePromise(() => onNext(value), iteratorResult, abruptClose));
+  }
+  let mapReject;
+  if (onError) {
+    let onErrorResult;
+    const reject = onError;
+    mapReject = (error) => {
+      onErrorResult ||= handleMaybePromise(() => error, (error2) => handleMaybePromise(() => reject(error2), iteratorResult, abruptClose));
+      return onErrorResult;
+    };
+  }
+  return {
+    next() {
+      return iterator.next().then(mapResult, mapReject);
+    },
+    return() {
+      const res$ = $return ? $return.call(iterator).then(mapResult, mapReject) : fakePromise({ value: void 0, done: true });
+      return res$;
+    },
+    throw(error) {
+      if (typeof iterator.throw === "function") {
+        return iterator.throw(error).then(mapResult, mapReject);
+      }
+      if (abruptClose) {
+        return abruptClose(error);
+      }
+      return fakeRejectPromise(error);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function iteratorResult(value) {
+  return { value, done: false };
+}
+function isFakePromise(value) {
+  return value?.[kFakePromise] === "resolved";
+}
+function isFakeRejectPromise(value) {
+  return value?.[kFakePromise] === "rejected";
+}
+function promiseLikeFinally(value, onFinally) {
+  if ("finally" in value) {
+    return value.finally(onFinally);
+  }
+  return value.then((res) => {
+    const finallyRes = onFinally();
+    return isPromise(finallyRes) ? finallyRes.then(() => res) : res;
+  }, (err) => {
+    const finallyRes = onFinally();
+    if (isPromise(finallyRes)) {
+      return finallyRes.then(() => {
+        throw err;
+      });
+    } else {
+      throw err;
+    }
+  });
+}
+function unfakePromise(promise) {
+  if (isFakePromise(promise)) {
+    return promise.__fakePromiseValue;
+  }
+  if (isFakeRejectPromise(promise)) {
+    throw promise.__fakeRejectError;
+  }
+  return promise;
+}
+export {
+  createDeferredPromise,
+  fakePromise,
+  fakeRejectPromise,
+  handleMaybePromise,
+  isActualPromise,
+  isPromise,
+  iterateAsync,
+  iterateAsync as iterateAsyncVoid,
+  mapAsyncIterator,
+  promiseLikeFinally,
+  unfakePromise
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@whatwg-node/promise-helpers/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/@whatwg-node/promise-helpers/esm/index.js"],"sourcesContent":["const kFakePromise = Symbol.for('@whatwg-node/promise-helpers/FakePromise');\nexport function isPromise(value) {\n    return value?.then != null;\n}\nexport function isActualPromise(value) {\n    const maybePromise = value;\n    return maybePromise && maybePromise.then && maybePromise.catch && maybePromise.finally;\n}\nexport function handleMaybePromise(inputFactory, outputSuccessFactory, outputErrorFactory, finallyFactory) {\n    let result$ = fakePromise().then(inputFactory).then(outputSuccessFactory, outputErrorFactory);\n    if (finallyFactory) {\n        result$ = result$.finally(finallyFactory);\n    }\n    return unfakePromise(result$);\n}\nexport function fakePromise(value) {\n    if (value && isActualPromise(value)) {\n        return value;\n    }\n    if (isPromise(value)) {\n        return {\n            then: (resolve, reject) => fakePromise(value.then(resolve, reject)),\n            catch: reject => fakePromise(value.then(res => res, reject)),\n            finally: cb => fakePromise(cb ? promiseLikeFinally(value, cb) : value),\n            [Symbol.toStringTag]: 'Promise',\n        };\n    }\n    // Write a fake promise to avoid the promise constructor\n    // being called with `new Promise` in the browser.\n    return {\n        then(resolve) {\n            if (resolve) {\n                try {\n                    return fakePromise(resolve(value));\n                }\n                catch (err) {\n                    return fakeRejectPromise(err);\n                }\n            }\n            return this;\n        },\n        catch() {\n            return this;\n        },\n        finally(cb) {\n            if (cb) {\n                try {\n                    return fakePromise(cb()).then(() => value, () => value);\n                }\n                catch (err) {\n                    return fakeRejectPromise(err);\n                }\n            }\n            return this;\n        },\n        [Symbol.toStringTag]: 'Promise',\n        __fakePromiseValue: value,\n        [kFakePromise]: 'resolved',\n    };\n}\nexport function createDeferredPromise() {\n    if (Promise.withResolvers) {\n        return Promise.withResolvers();\n    }\n    let resolveFn;\n    let rejectFn;\n    const promise = new Promise(function deferredPromiseExecutor(resolve, reject) {\n        resolveFn = resolve;\n        rejectFn = reject;\n    });\n    return {\n        promise,\n        get resolve() {\n            return resolveFn;\n        },\n        get reject() {\n            return rejectFn;\n        },\n    };\n}\nexport { iterateAsync as iterateAsyncVoid };\nexport function iterateAsync(iterable, callback, results) {\n    if (iterable?.length === 0) {\n        return;\n    }\n    const iterator = iterable[Symbol.iterator]();\n    let index = 0;\n    function iterate() {\n        const { done: endOfIterator, value } = iterator.next();\n        if (endOfIterator) {\n            return;\n        }\n        let endedEarly = false;\n        function endEarly() {\n            endedEarly = true;\n        }\n        return handleMaybePromise(function handleCallback() {\n            return callback(value, endEarly, index++);\n        }, function handleCallbackResult(result) {\n            if (result) {\n                results?.push(result);\n            }\n            if (endedEarly) {\n                return;\n            }\n            return iterate();\n        });\n    }\n    return iterate();\n}\nexport function fakeRejectPromise(error) {\n    return {\n        then(_resolve, reject) {\n            if (reject) {\n                try {\n                    return fakePromise(reject(error));\n                }\n                catch (err) {\n                    return fakeRejectPromise(err);\n                }\n            }\n            return this;\n        },\n        catch(reject) {\n            if (reject) {\n                try {\n                    return fakePromise(reject(error));\n                }\n                catch (err) {\n                    return fakeRejectPromise(err);\n                }\n            }\n            return this;\n        },\n        finally(cb) {\n            if (cb) {\n                try {\n                    cb();\n                }\n                catch (err) {\n                    return fakeRejectPromise(err);\n                }\n            }\n            return this;\n        },\n        __fakeRejectError: error,\n        [Symbol.toStringTag]: 'Promise',\n        [kFakePromise]: 'rejected',\n    };\n}\nexport function mapMaybePromise(input, onSuccess, onError) {\n    return handleMaybePromise(() => input, onSuccess, onError);\n}\n/**\n * Given an AsyncIterable and a callback function, return an AsyncIterator\n * which produces values mapped via calling the callback function.\n */\nexport function mapAsyncIterator(iterator, onNext, onError, onEnd) {\n    if (Symbol.asyncIterator in iterator) {\n        iterator = iterator[Symbol.asyncIterator]();\n    }\n    let $return;\n    let abruptClose;\n    let onEndWithValue;\n    if (onEnd) {\n        let onEndWithValueResult /** R in onEndWithValue */;\n        onEndWithValue = value => {\n            onEndWithValueResult ||= handleMaybePromise(onEnd, () => value, () => value);\n            return onEndWithValueResult;\n        };\n    }\n    if (typeof iterator.return === 'function') {\n        $return = iterator.return;\n        abruptClose = (error) => {\n            const rethrow = () => {\n                throw error;\n            };\n            return $return.call(iterator).then(rethrow, rethrow);\n        };\n    }\n    function mapResult(result) {\n        if (result.done) {\n            return onEndWithValue ? onEndWithValue(result) : result;\n        }\n        return handleMaybePromise(() => result.value, value => handleMaybePromise(() => onNext(value), iteratorResult, abruptClose));\n    }\n    let mapReject;\n    if (onError) {\n        let onErrorResult;\n        // Capture rejectCallback to ensure it cannot be null.\n        const reject = onError;\n        mapReject = (error) => {\n            onErrorResult ||= handleMaybePromise(() => error, error => handleMaybePromise(() => reject(error), iteratorResult, abruptClose));\n            return onErrorResult;\n        };\n    }\n    return {\n        next() {\n            return iterator.next().then(mapResult, mapReject);\n        },\n        return() {\n            const res$ = $return\n                ? $return.call(iterator).then(mapResult, mapReject)\n                : fakePromise({ value: undefined, done: true });\n            return onEndWithValue ? res$.then(onEndWithValue) : res$;\n        },\n        throw(error) {\n            if (typeof iterator.throw === 'function') {\n                return iterator.throw(error).then(mapResult, mapReject);\n            }\n            if (abruptClose) {\n                return abruptClose(error);\n            }\n            return fakeRejectPromise(error);\n        },\n        [Symbol.asyncIterator]() {\n            return this;\n        },\n    };\n}\nfunction iteratorResult(value) {\n    return { value, done: false };\n}\nfunction isFakePromise(value) {\n    return value?.[kFakePromise] === 'resolved';\n}\nfunction isFakeRejectPromise(value) {\n    return value?.[kFakePromise] === 'rejected';\n}\nexport function promiseLikeFinally(value, onFinally) {\n    if ('finally' in value) {\n        return value.finally(onFinally);\n    }\n    return value.then(res => {\n        const finallyRes = onFinally();\n        return isPromise(finallyRes) ? finallyRes.then(() => res) : res;\n    }, err => {\n        const finallyRes = onFinally();\n        if (isPromise(finallyRes)) {\n            return finallyRes.then(() => {\n                throw err;\n            });\n        }\n        else {\n            throw err;\n        }\n    });\n}\nexport function unfakePromise(promise) {\n    if (isFakePromise(promise)) {\n        return promise.__fakePromiseValue;\n    }\n    if (isFakeRejectPromise(promise)) {\n        throw promise.__fakeRejectError;\n    }\n    return promise;\n}\n"],"names":["error"],"mappings":"AAAA,MAAM,eAAe,OAAO,IAAI,0CAA0C;AACnE,SAAS,UAAU,OAAO;AAC7B,SAAO,OAAO,QAAQ;AAC1B;AACO,SAAS,gBAAgB,OAAO;AACnC,QAAM,eAAe;AACrB,SAAO,gBAAgB,aAAa,QAAQ,aAAa,SAAS,aAAa;AACnF;AACO,SAAS,mBAAmB,cAAc,sBAAsB,oBAAoB,gBAAgB;AACvG,MAAI,UAAU,YAAW,EAAG,KAAK,YAAY,EAAE,KAAK,sBAAsB,kBAAkB;AAI5F,SAAO,cAAc,OAAO;AAChC;AACO,SAAS,YAAY,OAAO;AAC/B,MAAI,SAAS,gBAAgB,KAAK,GAAG;AACjC,WAAO;AAAA,EACX;AACA,MAAI,UAAU,KAAK,GAAG;AAClB,WAAO;AAAA,MACH,MAAM,CAAC,SAAS,WAAW,YAAY,MAAM,KAAK,SAAS,MAAM,CAAC;AAAA,MAClE,OAAO,YAAU,YAAY,MAAM,KAAK,SAAO,KAAK,MAAM,CAAC;AAAA,MAC3D,SAAS,QAAM,YAAY,KAAK,mBAAmB,OAAO,EAAE,IAAI,KAAK;AAAA,MACrE,CAAC,OAAO,WAAW,GAAG;AAAA,IAClC;AAAA,EACI;AAGA,SAAO;AAAA,IACH,KAAK,SAAS;AACV,UAAI,SAAS;AACT,YAAI;AACA,iBAAO,YAAY,QAAQ,KAAK,CAAC;AAAA,QACrC,SACO,KAAK;AACR,iBAAO,kBAAkB,GAAG;AAAA,QAChC;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA,IACA,QAAQ;AACJ,aAAO;AAAA,IACX;AAAA,IACA,QAAQ,IAAI;AACR,UAAI,IAAI;AACJ,YAAI;AACA,iBAAO,YAAY,IAAI,EAAE,KAAK,MAAM,OAAO,MAAM,KAAK;AAAA,QAC1D,SACO,KAAK;AACR,iBAAO,kBAAkB,GAAG;AAAA,QAChC;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA,IACA,CAAC,OAAO,WAAW,GAAG;AAAA,IACtB,oBAAoB;AAAA,IACpB,CAAC,YAAY,GAAG;AAAA,EACxB;AACA;AACO,SAAS,wBAAwB;AACpC,MAAI,QAAQ,eAAe;AACvB,WAAO,QAAQ,cAAa;AAAA,EAChC;AACA,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAQ,SAAS,wBAAwB,SAAS,QAAQ;AAC1E,gBAAY;AACZ,eAAW;AAAA,EACf,CAAC;AACD,SAAO;AAAA,IACH;AAAA,IACA,IAAI,UAAU;AACV,aAAO;AAAA,IACX;AAAA,IACA,IAAI,SAAS;AACT,aAAO;AAAA,IACX;AAAA,EACR;AACA;AAEO,SAAS,aAAa,UAAU,UAAU,SAAS;AACtD,MAAI,UAAU,WAAW,GAAG;AACxB;AAAA,EACJ;AACA,QAAM,WAAW,SAAS,OAAO,QAAQ,EAAC;AAC1C,MAAI,QAAQ;AACZ,WAAS,UAAU;AACf,UAAM,EAAE,MAAM,eAAe,MAAK,IAAK,SAAS,KAAI;AACpD,QAAI,eAAe;AACf;AAAA,IACJ;AACA,QAAI,aAAa;AACjB,aAAS,WAAW;AAChB,mBAAa;AAAA,IACjB;AACA,WAAO,mBAAmB,SAAS,iBAAiB;AAChD,aAAO,SAAS,OAAO,UAAU,OAAO;AAAA,IAC5C,GAAG,SAAS,qBAAqB,QAAQ;AACrC,UAAI,QAAQ;AACR,iBAAS,KAAK,MAAM;AAAA,MACxB;AACA,UAAI,YAAY;AACZ;AAAA,MACJ;AACA,aAAO,QAAO;AAAA,IAClB,CAAC;AAAA,EACL;AACA,SAAO,QAAO;AAClB;AACO,SAAS,kBAAkB,OAAO;AACrC,SAAO;AAAA,IACH,KAAK,UAAU,QAAQ;AACnB,UAAI,QAAQ;AACR,YAAI;AACA,iBAAO,YAAY,OAAO,KAAK,CAAC;AAAA,QACpC,SACO,KAAK;AACR,iBAAO,kBAAkB,GAAG;AAAA,QAChC;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA,IACA,MAAM,QAAQ;AACV,UAAI,QAAQ;AACR,YAAI;AACA,iBAAO,YAAY,OAAO,KAAK,CAAC;AAAA,QACpC,SACO,KAAK;AACR,iBAAO,kBAAkB,GAAG;AAAA,QAChC;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA,IACA,QAAQ,IAAI;AACR,UAAI,IAAI;AACJ,YAAI;AACA,aAAE;AAAA,QACN,SACO,KAAK;AACR,iBAAO,kBAAkB,GAAG;AAAA,QAChC;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA,IACA,mBAAmB;AAAA,IACnB,CAAC,OAAO,WAAW,GAAG;AAAA,IACtB,CAAC,YAAY,GAAG;AAAA,EACxB;AACA;AAQO,SAAS,iBAAiB,UAAU,QAAQ,SAAS,OAAO;AAC/D,MAAI,OAAO,iBAAiB,UAAU;AAClC,eAAW,SAAS,OAAO,aAAa,EAAC;AAAA,EAC7C;AACA,MAAI;AACJ,MAAI;AASJ,MAAI,OAAO,SAAS,WAAW,YAAY;AACvC,cAAU,SAAS;AACnB,kBAAc,CAAC,UAAU;AACrB,YAAM,UAAU,MAAM;AAClB,cAAM;AAAA,MACV;AACA,aAAO,QAAQ,KAAK,QAAQ,EAAE,KAAK,SAAS,OAAO;AAAA,IACvD;AAAA,EACJ;AACA,WAAS,UAAU,QAAQ;AACvB,QAAI,OAAO,MAAM;AACb,aAAiD;AAAA,IACrD;AACA,WAAO,mBAAmB,MAAM,OAAO,OAAO,WAAS,mBAAmB,MAAM,OAAO,KAAK,GAAG,gBAAgB,WAAW,CAAC;AAAA,EAC/H;AACA,MAAI;AACJ,MAAI,SAAS;AACT,QAAI;AAEJ,UAAM,SAAS;AACf,gBAAY,CAAC,UAAU;AACnB,wBAAkB,mBAAmB,MAAM,OAAO,CAAAA,WAAS,mBAAmB,MAAM,OAAOA,MAAK,GAAG,gBAAgB,WAAW,CAAC;AAC/H,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AAAA,IACH,OAAO;AACH,aAAO,SAAS,KAAI,EAAG,KAAK,WAAW,SAAS;AAAA,IACpD;AAAA,IACA,SAAS;AACL,YAAM,OAAO,UACP,QAAQ,KAAK,QAAQ,EAAE,KAAK,WAAW,SAAS,IAChD,YAAY,EAAE,OAAO,QAAW,MAAM,KAAI,CAAE;AAClD,aAAoD;AAAA,IACxD;AAAA,IACA,MAAM,OAAO;AACT,UAAI,OAAO,SAAS,UAAU,YAAY;AACtC,eAAO,SAAS,MAAM,KAAK,EAAE,KAAK,WAAW,SAAS;AAAA,MAC1D;AACA,UAAI,aAAa;AACb,eAAO,YAAY,KAAK;AAAA,MAC5B;AACA,aAAO,kBAAkB,KAAK;AAAA,IAClC;AAAA,IACA,CAAC,OAAO,aAAa,IAAI;AACrB,aAAO;AAAA,IACX;AAAA,EACR;AACA;AACA,SAAS,eAAe,OAAO;AAC3B,SAAO,EAAE,OAAO,MAAM,MAAK;AAC/B;AACA,SAAS,cAAc,OAAO;AAC1B,SAAO,QAAQ,YAAY,MAAM;AACrC;AACA,SAAS,oBAAoB,OAAO;AAChC,SAAO,QAAQ,YAAY,MAAM;AACrC;AACO,SAAS,mBAAmB,OAAO,WAAW;AACjD,MAAI,aAAa,OAAO;AACpB,WAAO,MAAM,QAAQ,SAAS;AAAA,EAClC;AACA,SAAO,MAAM,KAAK,SAAO;AACrB,UAAM,aAAa,UAAS;AAC5B,WAAO,UAAU,UAAU,IAAI,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,EAChE,GAAG,SAAO;AACN,UAAM,aAAa,UAAS;AAC5B,QAAI,UAAU,UAAU,GAAG;AACvB,aAAO,WAAW,KAAK,MAAM;AACzB,cAAM;AAAA,MACV,CAAC;AAAA,IACL,OACK;AACD,YAAM;AAAA,IACV;AAAA,EACJ,CAAC;AACL;AACO,SAAS,cAAc,SAAS;AACnC,MAAI,cAAc,OAAO,GAAG;AACxB,WAAO,QAAQ;AAAA,EACnB;AACA,MAAI,oBAAoB,OAAO,GAAG;AAC9B,UAAM,QAAQ;AAAA,EAClB;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/@whatwg-node/server/esm/createServerAdapter.js

@@ -0,0 +1,333 @@
+import { AsyncDisposableStack } from "../../disposablestack/esm/index.js";
+import * as globalPonyfill from "../../../../_virtual/global-ponyfill.js";
+import { fakePromise, isPromise, handleMaybePromise, unfakePromise, iterateAsyncVoid as iterateAsync } from "../../promise-helpers/esm/index.js";
+import { ensureDisposableStackRegisteredForTerminateEvents, isNodeRequest, isServerResponse, isFetchEvent, completeAssign, createCustomAbortControllerSignal, handleErrorFromRequestHandler, isolateObject, sendNodeResponse, normalizeNodeRequest, isRequestInit, handleAbortSignalAndPromiseResponse } from "./utils.js";
+import { isUWSResponse, getRequestFromUWSRequest, sendResponseToUwsOpts } from "./uwebsockets.js";
+import { chain, getInstrumented } from "../../../@envelop/instrumentation/esm/instrumentation.js";
+import { DisposableSymbols } from "../../disposablestack/esm/symbols.js";
+function isRequestAccessible(serverContext) {
+  try {
+    return !!serverContext?.request;
+  } catch {
+    return false;
+  }
+}
+const EMPTY_OBJECT = {};
+function createServerAdapter(serverAdapterBaseObject, options) {
+  const useSingleWriteHead = options?.__useSingleWriteHead == null ? true : options.__useSingleWriteHead;
+  const fetchAPI = {
+    ...globalPonyfill,
+    ...options?.fetchAPI
+  };
+  const useCustomAbortCtrl = options?.__useCustomAbortCtrl == null ? fetchAPI.Request !== globalThis.Request : options.__useCustomAbortCtrl;
+  const givenHandleRequest = typeof serverAdapterBaseObject === "function" ? serverAdapterBaseObject : serverAdapterBaseObject.handle;
+  const onRequestHooks = [];
+  const onResponseHooks = [];
+  let instrumentation;
+  const waitUntilPromises = /* @__PURE__ */ new Set();
+  let _disposableStack;
+  function ensureDisposableStack() {
+    if (!_disposableStack) {
+      _disposableStack = new AsyncDisposableStack();
+      if (options?.disposeOnProcessTerminate) {
+        ensureDisposableStackRegisteredForTerminateEvents(_disposableStack);
+      }
+      _disposableStack.defer(() => {
+        if (waitUntilPromises.size > 0) {
+          return Promise.allSettled(waitUntilPromises).then(() => {
+            waitUntilPromises.clear();
+          }, () => {
+            waitUntilPromises.clear();
+          });
+        }
+      });
+    }
+    return _disposableStack;
+  }
+  function waitUntil(maybePromise) {
+    if (isPromise(maybePromise)) {
+      ensureDisposableStack();
+      waitUntilPromises.add(maybePromise);
+      maybePromise.then(() => {
+        waitUntilPromises.delete(maybePromise);
+      }, (err) => {
+        console.error(`Unexpected error while waiting: ${err.message || err}`);
+        waitUntilPromises.delete(maybePromise);
+      });
+    }
+  }
+  if (options?.plugins != null) {
+    for (const plugin of options.plugins) {
+      if (plugin.instrumentation) {
+        instrumentation = instrumentation ? chain(instrumentation, plugin.instrumentation) : plugin.instrumentation;
+      }
+      if (plugin.onRequest) {
+        onRequestHooks.push(plugin.onRequest);
+      }
+      if (plugin.onResponse) {
+        onResponseHooks.push(plugin.onResponse);
+      }
+      const disposeFn = plugin[DisposableSymbols.dispose];
+      if (disposeFn) {
+        ensureDisposableStack().defer(disposeFn);
+      }
+      const asyncDisposeFn = plugin[DisposableSymbols.asyncDispose];
+      if (asyncDisposeFn) {
+        ensureDisposableStack().defer(asyncDisposeFn);
+      }
+      if (plugin.onDispose) {
+        ensureDisposableStack().defer(plugin.onDispose);
+      }
+    }
+  }
+  let handleRequest = onRequestHooks.length > 0 || onResponseHooks.length > 0 ? function handleRequest2(request, serverContext) {
+    let requestHandler = givenHandleRequest;
+    let response;
+    if (onRequestHooks.length === 0) {
+      return handleEarlyResponse();
+    }
+    let url = request["parsedUrl"] || new Proxy(EMPTY_OBJECT, {
+      get(_target, prop, _receiver) {
+        url = new fetchAPI.URL(request.url, "http://localhost");
+        return Reflect.get(url, prop, url);
+      }
+    });
+    function handleResponse(response2) {
+      if (onResponseHooks.length === 0) {
+        return response2;
+      }
+      return handleMaybePromise(() => iterateAsync(onResponseHooks, (onResponseHook) => onResponseHook({
+        request,
+        response: response2,
+        serverContext,
+        setResponse(newResponse) {
+          response2 = newResponse;
+        },
+        fetchAPI
+      })), () => response2);
+    }
+    function handleEarlyResponse() {
+      if (!response) {
+        return handleMaybePromise(() => requestHandler(request, serverContext), handleResponse);
+      }
+      return handleResponse(response);
+    }
+    return handleMaybePromise(() => iterateAsync(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
+      request,
+      setRequest(newRequest) {
+        request = newRequest;
+      },
+      serverContext,
+      fetchAPI,
+      url,
+      requestHandler,
+      setRequestHandler(newRequestHandler) {
+        requestHandler = newRequestHandler;
+      },
+      endResponse(newResponse) {
+        response = newResponse;
+        if (newResponse) {
+          stopEarly();
+        }
+      }
+    })), handleEarlyResponse);
+  } : givenHandleRequest;
+  if (instrumentation?.request) {
+    const originalRequestHandler = handleRequest;
+    handleRequest = (request, initialContext) => {
+      return getInstrumented({ request }).asyncFn(instrumentation.request, originalRequestHandler)(request, initialContext);
+    };
+  }
+  function handleNodeRequest(nodeRequest, ...ctx) {
+    const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};
+    if (!serverContext.waitUntil) {
+      serverContext.waitUntil = waitUntil;
+    }
+    const request = normalizeNodeRequest(nodeRequest, fetchAPI, void 0, useCustomAbortCtrl);
+    return handleRequest(request, serverContext);
+  }
+  function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
+    const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+    const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};
+    if (!serverContext.waitUntil) {
+      serverContext.waitUntil = waitUntil;
+    }
+    const request = normalizeNodeRequest(nodeRequest, fetchAPI, nodeResponse, useCustomAbortCtrl);
+    return handleRequest(request, serverContext);
+  }
+  function requestListener(nodeRequest, nodeResponse, ...ctx) {
+    const defaultServerContext = {
+      req: nodeRequest,
+      res: nodeResponse,
+      waitUntil
+    };
+    return unfakePromise(fakePromise().then(() => handleNodeRequestAndResponse(nodeRequest, nodeResponse, defaultServerContext, ...ctx)).catch((err) => handleErrorFromRequestHandler(err, fetchAPI.Response)).then((response) => sendNodeResponse(response, nodeResponse, nodeRequest, useSingleWriteHead)).catch((err) => console.error(`Unexpected error while handling request: ${err.message || err}`)));
+  }
+  function handleUWS(res, req, ...ctx) {
+    const defaultServerContext = {
+      res,
+      req,
+      waitUntil
+    };
+    const filteredCtxParts = ctx.filter((partCtx) => partCtx != null);
+    const serverContext = filteredCtxParts.length > 0 ? completeAssign(defaultServerContext, ...ctx) : defaultServerContext;
+    const controller = useCustomAbortCtrl ? createCustomAbortControllerSignal() : new AbortController();
+    const originalResEnd = res.end.bind(res);
+    let resEnded = false;
+    res.end = function(data) {
+      resEnded = true;
+      return originalResEnd(data);
+    };
+    const originalOnAborted = res.onAborted.bind(res);
+    originalOnAborted(function() {
+      controller.abort();
+    });
+    res.onAborted = function(cb) {
+      controller.signal.addEventListener("abort", cb, { once: true });
+    };
+    const request = getRequestFromUWSRequest({
+      req,
+      res,
+      fetchAPI,
+      controller
+    });
+    return handleMaybePromise(() => handleMaybePromise(() => handleRequest(request, serverContext), (response) => response, (err) => handleErrorFromRequestHandler(err, fetchAPI.Response)), (response) => {
+      if (!controller.signal.aborted && !resEnded) {
+        return handleMaybePromise(() => sendResponseToUwsOpts(res, response, controller, fetchAPI), (r) => r, (err) => {
+          console.error(`Unexpected error while handling request: ${err.message || err}`);
+        });
+      }
+    });
+  }
+  function handleEvent(event, ...ctx) {
+    if (!event.respondWith || !event.request) {
+      throw new TypeError(`Expected FetchEvent, got ${event}`);
+    }
+    const filteredCtxParts = ctx.filter((partCtx) => partCtx != null);
+    const serverContext = filteredCtxParts.length > 0 ? completeAssign({}, event, ...filteredCtxParts) : isolateObject(event);
+    const response$ = handleRequest(event.request, serverContext);
+    event.respondWith(response$);
+  }
+  function handleRequestWithWaitUntil(request, ...ctx) {
+    const filteredCtxParts = ctx.filter((partCtx) => partCtx != null);
+    const serverContext = filteredCtxParts.length > 1 ? completeAssign({}, ...filteredCtxParts) : isolateObject(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null ? waitUntil : void 0);
+    return handleRequest(request, serverContext);
+  }
+  const fetchFn = (input, ...maybeCtx) => {
+    if (typeof input === "string" || "href" in input) {
+      const [initOrCtx, ...restOfCtx] = maybeCtx;
+      if (isRequestInit(initOrCtx)) {
+        const request2 = new fetchAPI.Request(input, initOrCtx);
+        const res$2 = handleRequestWithWaitUntil(request2, ...restOfCtx);
+        const signal = initOrCtx.signal;
+        if (signal) {
+          return handleAbortSignalAndPromiseResponse(res$2, signal);
+        }
+        return res$2;
+      }
+      const request = new fetchAPI.Request(input);
+      return handleRequestWithWaitUntil(request, ...maybeCtx);
+    }
+    const res$ = handleRequestWithWaitUntil(input, ...maybeCtx);
+    return handleAbortSignalAndPromiseResponse(res$, input.signal);
+  };
+  const genericRequestHandler = (input, ...maybeCtx) => {
+    const [initOrCtxOrRes, ...restOfCtx] = maybeCtx;
+    if (isNodeRequest(input)) {
+      if (!isServerResponse(initOrCtxOrRes)) {
+        throw new TypeError(`Expected ServerResponse, got ${initOrCtxOrRes}`);
+      }
+      return requestListener(input, initOrCtxOrRes, ...restOfCtx);
+    }
+    if (isUWSResponse(input)) {
+      return handleUWS(input, initOrCtxOrRes, ...restOfCtx);
+    }
+    if (isServerResponse(initOrCtxOrRes)) {
+      throw new TypeError("Got Node response without Node request");
+    }
+    if (isRequestAccessible(input)) {
+      if (isFetchEvent(input)) {
+        return handleEvent(input, ...maybeCtx);
+      }
+      return handleRequestWithWaitUntil(input.request, input, ...maybeCtx);
+    }
+    return fetchFn(input, ...maybeCtx);
+  };
+  const adapterObj = {
+    handleRequest: handleRequestWithWaitUntil,
+    fetch: fetchFn,
+    handleNodeRequest,
+    handleNodeRequestAndResponse,
+    requestListener,
+    handleEvent,
+    handleUWS,
+    handle: genericRequestHandler,
+    get disposableStack() {
+      return ensureDisposableStack();
+    },
+    [DisposableSymbols.asyncDispose]() {
+      if (_disposableStack && !_disposableStack.disposed) {
+        return _disposableStack.disposeAsync();
+      }
+      return fakePromise();
+    },
+    dispose() {
+      if (_disposableStack && !_disposableStack.disposed) {
+        return _disposableStack.disposeAsync();
+      }
+      return fakePromise();
+    },
+    waitUntil
+  };
+  const serverAdapter = new Proxy(genericRequestHandler, {
+    // It should have all the attributes of the handler function and the server instance
+    has: (_, prop) => {
+      return prop in adapterObj || prop in genericRequestHandler || serverAdapterBaseObject && prop in serverAdapterBaseObject;
+    },
+    get: (_, prop) => {
+      if (globalThis.Deno || prop === Symbol.asyncDispose || prop === Symbol.dispose) {
+        const adapterProp2 = Reflect.get(adapterObj, prop, adapterObj);
+        if (adapterProp2) {
+          return adapterProp2;
+        }
+      }
+      const adapterProp = adapterObj[prop];
+      if (adapterProp) {
+        if (adapterProp.bind) {
+          return adapterProp.bind(adapterObj);
+        }
+        return adapterProp;
+      }
+      const handleProp = genericRequestHandler[prop];
+      if (handleProp) {
+        if (handleProp.bind) {
+          return handleProp.bind(genericRequestHandler);
+        }
+        return handleProp;
+      }
+      if (serverAdapterBaseObject) {
+        const serverAdapterBaseObjectProp = serverAdapterBaseObject[prop];
+        if (serverAdapterBaseObjectProp) {
+          if (serverAdapterBaseObjectProp.bind) {
+            return function(...args) {
+              const returnedVal = serverAdapterBaseObject[prop](...args);
+              if (returnedVal === serverAdapterBaseObject) {
+                return serverAdapter;
+              }
+              return returnedVal;
+            };
+          }
+          return serverAdapterBaseObjectProp;
+        }
+      }
+    },
+    apply(_, __, args) {
+      return genericRequestHandler(...args);
+    }
+  });
+  return serverAdapter;
+}
+export {
+  createServerAdapter
+};
+//# sourceMappingURL=createServerAdapter.js.map