| "use strict"; |
| var __defProp = Object.defineProperty; |
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
| var __getOwnPropNames = Object.getOwnPropertyNames; |
| var __hasOwnProp = Object.prototype.hasOwnProperty; |
| var __export = (target, all) => { |
| for (var name in all) |
| __defProp(target, name, { get: all[name], enumerable: true }); |
| }; |
| var __copyProps = (to, from, except, desc) => { |
| if (from && typeof from === "object" || typeof from === "function") { |
| for (let key of __getOwnPropNames(from)) |
| if (!__hasOwnProp.call(to, key) && key !== except) |
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
| } |
| return to; |
| }; |
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
| |
| // pkg/dist-src/index.js |
| var dist_src_exports = {}; |
| __export(dist_src_exports, { |
| request: () => request |
| }); |
| module.exports = __toCommonJS(dist_src_exports); |
| var import_endpoint = require("@octokit/endpoint"); |
| var import_universal_user_agent = require("universal-user-agent"); |
| |
| // pkg/dist-src/version.js |
| var VERSION = "8.2.0"; |
| |
| // pkg/dist-src/is-plain-object.js |
| function isPlainObject(value) { |
| if (typeof value !== "object" || value === null) |
| return false; |
| if (Object.prototype.toString.call(value) !== "[object Object]") |
| return false; |
| const proto = Object.getPrototypeOf(value); |
| if (proto === null) |
| return true; |
| const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; |
| return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); |
| } |
| |
| // pkg/dist-src/fetch-wrapper.js |
| var import_request_error = require("@octokit/request-error"); |
| |
| // pkg/dist-src/get-buffer-response.js |
| function getBufferResponse(response) { |
| return response.arrayBuffer(); |
| } |
| |
| // pkg/dist-src/fetch-wrapper.js |
| function fetchWrapper(requestOptions) { |
| var _a, _b, _c; |
| const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; |
| const parseSuccessResponseBody = ((_a = requestOptions.request) == null ? void 0 : _a.parseSuccessResponseBody) !== false; |
| if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { |
| requestOptions.body = JSON.stringify(requestOptions.body); |
| } |
| let headers = {}; |
| let status; |
| let url; |
| let { fetch } = globalThis; |
| if ((_b = requestOptions.request) == null ? void 0 : _b.fetch) { |
| fetch = requestOptions.request.fetch; |
| } |
| if (!fetch) { |
| throw new Error( |
| "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing" |
| ); |
| } |
| return fetch(requestOptions.url, { |
| method: requestOptions.method, |
| body: requestOptions.body, |
| headers: requestOptions.headers, |
| signal: (_c = requestOptions.request) == null ? void 0 : _c.signal, |
| // duplex must be set if request.body is ReadableStream or Async Iterables. |
| // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex. |
| ...requestOptions.body && { duplex: "half" } |
| }).then(async (response) => { |
| url = response.url; |
| status = response.status; |
| for (const keyAndValue of response.headers) { |
| headers[keyAndValue[0]] = keyAndValue[1]; |
| } |
| if ("deprecation" in headers) { |
| const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/); |
| const deprecationLink = matches && matches.pop(); |
| log.warn( |
| `[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}` |
| ); |
| } |
| if (status === 204 || status === 205) { |
| return; |
| } |
| if (requestOptions.method === "HEAD") { |
| if (status < 400) { |
| return; |
| } |
| throw new import_request_error.RequestError(response.statusText, status, { |
| response: { |
| url, |
| status, |
| headers, |
| data: void 0 |
| }, |
| request: requestOptions |
| }); |
| } |
| if (status === 304) { |
| throw new import_request_error.RequestError("Not modified", status, { |
| response: { |
| url, |
| status, |
| headers, |
| data: await getResponseData(response) |
| }, |
| request: requestOptions |
| }); |
| } |
| if (status >= 400) { |
| const data = await getResponseData(response); |
| const error = new import_request_error.RequestError(toErrorMessage(data), status, { |
| response: { |
| url, |
| status, |
| headers, |
| data |
| }, |
| request: requestOptions |
| }); |
| throw error; |
| } |
| return parseSuccessResponseBody ? await getResponseData(response) : response.body; |
| }).then((data) => { |
| return { |
| status, |
| url, |
| headers, |
| data |
| }; |
| }).catch((error) => { |
| if (error instanceof import_request_error.RequestError) |
| throw error; |
| else if (error.name === "AbortError") |
| throw error; |
| let message = error.message; |
| if (error.name === "TypeError" && "cause" in error) { |
| if (error.cause instanceof Error) { |
| message = error.cause.message; |
| } else if (typeof error.cause === "string") { |
| message = error.cause; |
| } |
| } |
| throw new import_request_error.RequestError(message, 500, { |
| request: requestOptions |
| }); |
| }); |
| } |
| async function getResponseData(response) { |
| const contentType = response.headers.get("content-type"); |
| if (/application\/json/.test(contentType)) { |
| return response.json().catch(() => response.text()).catch(() => ""); |
| } |
| if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { |
| return response.text(); |
| } |
| return getBufferResponse(response); |
| } |
| function toErrorMessage(data) { |
| if (typeof data === "string") |
| return data; |
| let suffix; |
| if ("documentation_url" in data) { |
| suffix = ` - ${data.documentation_url}`; |
| } else { |
| suffix = ""; |
| } |
| if ("message" in data) { |
| if (Array.isArray(data.errors)) { |
| return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}${suffix}`; |
| } |
| return `${data.message}${suffix}`; |
| } |
| return `Unknown error: ${JSON.stringify(data)}`; |
| } |
| |
| // pkg/dist-src/with-defaults.js |
| function withDefaults(oldEndpoint, newDefaults) { |
| const endpoint2 = oldEndpoint.defaults(newDefaults); |
| const newApi = function(route, parameters) { |
| const endpointOptions = endpoint2.merge(route, parameters); |
| if (!endpointOptions.request || !endpointOptions.request.hook) { |
| return fetchWrapper(endpoint2.parse(endpointOptions)); |
| } |
| const request2 = (route2, parameters2) => { |
| return fetchWrapper( |
| endpoint2.parse(endpoint2.merge(route2, parameters2)) |
| ); |
| }; |
| Object.assign(request2, { |
| endpoint: endpoint2, |
| defaults: withDefaults.bind(null, endpoint2) |
| }); |
| return endpointOptions.request.hook(request2, endpointOptions); |
| }; |
| return Object.assign(newApi, { |
| endpoint: endpoint2, |
| defaults: withDefaults.bind(null, endpoint2) |
| }); |
| } |
| |
| // pkg/dist-src/index.js |
| var request = withDefaults(import_endpoint.endpoint, { |
| headers: { |
| "user-agent": `octokit-request.js/${VERSION} ${(0, import_universal_user_agent.getUserAgent)()}` |
| } |
| }); |
| // Annotate the CommonJS export names for ESM import in node: |
| 0 && (module.exports = { |
| request |
| }); |