cngpac 0.0.1

package/dist/src/node_modules/.pnpm/@octokit_graphql@9.0.3/node_modules/@octokit/graphql/dist-bundle/index.mjs

@@ -0,0 +1,90 @@
+import { getUserAgent } from "../../../../../universal-user-agent@7.0.3/node_modules/universal-user-agent/index.mjs";
+import { request } from "../../../../../@octokit_request@10.0.8/node_modules/@octokit/request/dist-bundle/index.mjs";
+//#region node_modules/.pnpm/@octokit+graphql@9.0.3/node_modules/@octokit/graphql/dist-bundle/index.js
+var VERSION = "0.0.0-development";
+function _buildMessageForResponseErrors(data) {
+	return `Request failed due to following response errors:
+` + data.errors.map((e) => ` - ${e.message}`).join("\n");
+}
+var GraphqlResponseError = class extends Error {
+	constructor(request2, headers, response) {
+		super(_buildMessageForResponseErrors(response));
+		this.request = request2;
+		this.headers = headers;
+		this.response = response;
+		this.errors = response.errors;
+		this.data = response.data;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+	name = "GraphqlResponseError";
+	errors;
+	data;
+};
+var NON_VARIABLE_OPTIONS = [
+	"method",
+	"baseUrl",
+	"url",
+	"headers",
+	"request",
+	"query",
+	"mediaType",
+	"operationName"
+];
+var FORBIDDEN_VARIABLE_OPTIONS = [
+	"query",
+	"method",
+	"url"
+];
+var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
+function graphql(request2, query, options) {
+	if (options) {
+		if (typeof query === "string" && "query" in options) return Promise.reject(/* @__PURE__ */ new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
+		for (const key in options) {
+			if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue;
+			return Promise.reject(/* @__PURE__ */ new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`));
+		}
+	}
+	const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
+	const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
+		if (NON_VARIABLE_OPTIONS.includes(key)) {
+			result[key] = parsedOptions[key];
+			return result;
+		}
+		if (!result.variables) result.variables = {};
+		result.variables[key] = parsedOptions[key];
+		return result;
+	}, {});
+	const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
+	if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
+	return request2(requestOptions).then((response) => {
+		if (response.data.errors) {
+			const headers = {};
+			for (const key of Object.keys(response.headers)) headers[key] = response.headers[key];
+			throw new GraphqlResponseError(requestOptions, headers, response.data);
+		}
+		return response.data.data;
+	});
+}
+function withDefaults(request2, newDefaults) {
+	const newRequest = request2.defaults(newDefaults);
+	const newApi = (query, options) => {
+		return graphql(newRequest, query, options);
+	};
+	return Object.assign(newApi, {
+		defaults: withDefaults.bind(null, newRequest),
+		endpoint: newRequest.endpoint
+	});
+}
+withDefaults(request, {
+	headers: { "user-agent": `octokit-graphql.js/${VERSION} ${getUserAgent()}` },
+	method: "POST",
+	url: "/graphql"
+});
+function withCustomRequest(customRequest) {
+	return withDefaults(customRequest, {
+		method: "POST",
+		url: "/graphql"
+	});
+}
+//#endregion
+export { withCustomRequest };

package/dist/src/node_modules/.pnpm/@octokit_plugin-paginate-rest@14.0.0_@octokit_core@7.0.6/node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.mjs

@@ -0,0 +1,86 @@
+//#region node_modules/.pnpm/@octokit+plugin-paginate-rest@14.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.js
+var VERSION = "0.0.0-development";
+function normalizePaginatedListResponse(response) {
+	if (!response.data) return {
+		...response,
+		data: []
+	};
+	if (!(("total_count" in response.data || "total_commits" in response.data) && !("url" in response.data))) return response;
+	const incompleteResults = response.data.incomplete_results;
+	const repositorySelection = response.data.repository_selection;
+	const totalCount = response.data.total_count;
+	const totalCommits = response.data.total_commits;
+	delete response.data.incomplete_results;
+	delete response.data.repository_selection;
+	delete response.data.total_count;
+	delete response.data.total_commits;
+	const namespaceKey = Object.keys(response.data)[0];
+	response.data = response.data[namespaceKey];
+	if (typeof incompleteResults !== "undefined") response.data.incomplete_results = incompleteResults;
+	if (typeof repositorySelection !== "undefined") response.data.repository_selection = repositorySelection;
+	response.data.total_count = totalCount;
+	response.data.total_commits = totalCommits;
+	return response;
+}
+function iterator(octokit, route, parameters) {
+	const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
+	const requestMethod = typeof route === "function" ? route : octokit.request;
+	const method = options.method;
+	const headers = options.headers;
+	let url = options.url;
+	return { [Symbol.asyncIterator]: () => ({ async next() {
+		if (!url) return { done: true };
+		try {
+			const normalizedResponse = normalizePaginatedListResponse(await requestMethod({
+				method,
+				url,
+				headers
+			}));
+			url = ((normalizedResponse.headers.link || "").match(/<([^<>]+)>;\s*rel="next"/) || [])[1];
+			if (!url && "total_commits" in normalizedResponse.data) {
+				const parsedUrl = new URL(normalizedResponse.url);
+				const params = parsedUrl.searchParams;
+				const page = parseInt(params.get("page") || "1", 10);
+				if (page * parseInt(params.get("per_page") || "250", 10) < normalizedResponse.data.total_commits) {
+					params.set("page", String(page + 1));
+					url = parsedUrl.toString();
+				}
+			}
+			return { value: normalizedResponse };
+		} catch (error) {
+			if (error.status !== 409) throw error;
+			url = "";
+			return { value: {
+				status: 200,
+				headers: {},
+				data: []
+			} };
+		}
+	} }) };
+}
+function paginate(octokit, route, parameters, mapFn) {
+	if (typeof parameters === "function") {
+		mapFn = parameters;
+		parameters = void 0;
+	}
+	return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
+}
+function gather(octokit, results, iterator2, mapFn) {
+	return iterator2.next().then((result) => {
+		if (result.done) return results;
+		let earlyExit = false;
+		function done() {
+			earlyExit = true;
+		}
+		results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
+		if (earlyExit) return results;
+		return gather(octokit, results, iterator2, mapFn);
+	});
+}
+Object.assign(paginate, { iterator });
+function paginateRest(octokit) {
+	return { paginate: Object.assign(paginate.bind(null, octokit), { iterator: iterator.bind(null, octokit) }) };
+}
+paginateRest.VERSION = VERSION;
+//#endregion
+export { paginateRest };

package/dist/src/node_modules/.pnpm/@octokit_plugin-request-log@6.0.0_@octokit_core@7.0.6/node_modules/@octokit/plugin-request-log/dist-src/index.mjs

@@ -0,0 +1,22 @@
+import { VERSION } from "./version.mjs";
+//#region node_modules/.pnpm/@octokit+plugin-request-log@6.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-request-log/dist-src/index.js
+function requestLog(octokit) {
+	octokit.hook.wrap("request", (request, options) => {
+		octokit.log.debug("request", options);
+		const start = Date.now();
+		const requestOptions = octokit.request.endpoint.parse(options);
+		const path = requestOptions.url.replace(options.baseUrl, "");
+		return request(options).then((response) => {
+			const requestId = response.headers["x-github-request-id"];
+			octokit.log.info(`${requestOptions.method} ${path} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`);
+			return response;
+		}).catch((error) => {
+			const requestId = error.response?.headers["x-github-request-id"] || "UNKNOWN";
+			octokit.log.error(`${requestOptions.method} ${path} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`);
+			throw error;
+		});
+	});
+}
+requestLog.VERSION = VERSION;
+//#endregion
+export { requestLog };

package/dist/src/node_modules/.pnpm/@octokit_plugin-request-log@6.0.0_@octokit_core@7.0.6/node_modules/@octokit/plugin-request-log/dist-src/version.mjs

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/@octokit+plugin-request-log@6.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-request-log/dist-src/version.js
+const VERSION = "6.0.0";
+//#endregion
+export { VERSION };

package/dist/src/node_modules/.pnpm/@octokit_plugin-rest-endpoint-methods@17.0.0_@octokit_core@7.0.6/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/endpoints-to-methods.mjs

@@ -0,0 +1,94 @@
+import { endpoints_default } from "./generated/endpoints.mjs";
+//#region node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/endpoints-to-methods.js
+const endpointMethodsMap = /* @__PURE__ */ new Map();
+for (const [scope, endpoints] of Object.entries(endpoints_default)) for (const [methodName, endpoint] of Object.entries(endpoints)) {
+	const [route, defaults, decorations] = endpoint;
+	const [method, url] = route.split(/ /);
+	const endpointDefaults = Object.assign({
+		method,
+		url
+	}, defaults);
+	if (!endpointMethodsMap.has(scope)) endpointMethodsMap.set(scope, /* @__PURE__ */ new Map());
+	endpointMethodsMap.get(scope).set(methodName, {
+		scope,
+		methodName,
+		endpointDefaults,
+		decorations
+	});
+}
+const handler = {
+	has({ scope }, methodName) {
+		return endpointMethodsMap.get(scope).has(methodName);
+	},
+	getOwnPropertyDescriptor(target, methodName) {
+		return {
+			value: this.get(target, methodName),
+			configurable: true,
+			writable: true,
+			enumerable: true
+		};
+	},
+	defineProperty(target, methodName, descriptor) {
+		Object.defineProperty(target.cache, methodName, descriptor);
+		return true;
+	},
+	deleteProperty(target, methodName) {
+		delete target.cache[methodName];
+		return true;
+	},
+	ownKeys({ scope }) {
+		return [...endpointMethodsMap.get(scope).keys()];
+	},
+	set(target, methodName, value) {
+		return target.cache[methodName] = value;
+	},
+	get({ octokit, scope, cache }, methodName) {
+		if (cache[methodName]) return cache[methodName];
+		const method = endpointMethodsMap.get(scope).get(methodName);
+		if (!method) return;
+		const { endpointDefaults, decorations } = method;
+		if (decorations) cache[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations);
+		else cache[methodName] = octokit.request.defaults(endpointDefaults);
+		return cache[methodName];
+	}
+};
+function endpointsToMethods(octokit) {
+	const newMethods = {};
+	for (const scope of endpointMethodsMap.keys()) newMethods[scope] = new Proxy({
+		octokit,
+		scope,
+		cache: {}
+	}, handler);
+	return newMethods;
+}
+function decorate(octokit, scope, methodName, defaults, decorations) {
+	const requestWithDefaults = octokit.request.defaults(defaults);
+	function withDecorations(...args) {
+		let options = requestWithDefaults.endpoint.merge(...args);
+		if (decorations.mapToData) {
+			options = Object.assign({}, options, {
+				data: options[decorations.mapToData],
+				[decorations.mapToData]: void 0
+			});
+			return requestWithDefaults(options);
+		}
+		if (decorations.renamed) {
+			const [newScope, newMethodName] = decorations.renamed;
+			octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`);
+		}
+		if (decorations.deprecated) octokit.log.warn(decorations.deprecated);
+		if (decorations.renamedParameters) {
+			const options2 = requestWithDefaults.endpoint.merge(...args);
+			for (const [name, alias] of Object.entries(decorations.renamedParameters)) if (name in options2) {
+				octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`);
+				if (!(alias in options2)) options2[alias] = options2[name];
+				delete options2[name];
+			}
+			return requestWithDefaults(options2);
+		}
+		return requestWithDefaults(...args);
+	}
+	return Object.assign(withDecorations, requestWithDefaults);
+}
+//#endregion
+export { endpointsToMethods };