builder-util-runtime - npm Package Compare versions

+13

dist/blockMapApi.d.ts

		export interface FileChunks {
		checksums: Array<string>;
		sizes: Array<number>;
		}
		export interface BlockMap {
		version: "1" \| "2";
		files: Array<BlockMapFile>;
		}
		export interface BlockMapFile extends FileChunks {
		name: string;
		offset: number;
		}
		//# sourceMappingURL=blockMapApi.d.ts.map

+1

dist/blockMapApi.d.ts.map

{"version":3,"file":"blockMapApi.d.ts","sourceRoot":"","sources":["../src/blockMapApi.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACxB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,GAAG,GAAG,GAAG,CAAA;IAClB,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf"}

+2

dist/blockMapApi.js

		export {};
		//# sourceMappingURL=blockMapApi.js.map

+1

dist/blockMapApi.js.map

{"version":3,"file":"blockMapApi.js","sourceRoot":"","sources":["../src/blockMapApi.ts"],"names":[],"mappings":"","sourcesContent":["export interface FileChunks {\n checksums: Array<string>\n sizes: Array<number>\n}\n\nexport interface BlockMap {\n version: \"1\" | \"2\"\n files: Array<BlockMapFile>\n}\n\nexport interface BlockMapFile extends FileChunks {\n name: string\n offset: number\n}\n"]}

+18

dist/CancellationToken.d.ts

		import { EventEmitter } from "events";
		export declare class CancellationToken extends EventEmitter {
		private parentCancelHandler;
		private _cancelled;
		get cancelled(): boolean;
		private _parent;
		set parent(value: CancellationToken);
		constructor(parent?: CancellationToken);
		cancel(): void;
		private onCancel;
		createPromise<R>(callback: (resolve: (thenableOrResult: R \| PromiseLike<R>) => void, reject: (error: Error) => void, onCancel: (callback: () => void) => void) => void): Promise<R>;
		private removeParentCancelHandler;
		dispose(): void;
		}
		export declare class CancellationError extends Error {
		constructor();
		}
		//# sourceMappingURL=CancellationToken.d.ts.map

+1

dist/CancellationToken.d.ts.map

{"version":3,"file":"CancellationToken.d.ts","sourceRoot":"","sources":["../src/CancellationToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAErC,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,OAAO,CAAC,mBAAmB,CAA2B;IAEtD,OAAO,CAAC,UAAU,CAAS;IAC3B,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,OAAO,CAAC,OAAO,CAAiC;IAChD,IAAI,MAAM,CAAC,KAAK,EAAE,iBAAiB,EAMlC;gBAGW,MAAM,CAAC,EAAE,iBAAiB;IAStC,MAAM;IAKN,OAAO,CAAC,QAAQ;IAQhB,aAAa,CAAC,CAAC,EACb,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,gBAAgB,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,GACpJ,OAAO,CAAC,CAAC,CAAC;IAoDb,OAAO,CAAC,yBAAyB;IAQjC,OAAO;CAQR;AAED,qBAAa,iBAAkB,SAAQ,KAAK;;CAI3C"}

+103

dist/CancellationToken.js

		import { EventEmitter } from "events";
		export class CancellationToken extends EventEmitter {
		get cancelled() {
		return this._cancelled \|\| (this._parent != null && this._parent.cancelled);
		}
		set parent(value) {
		this.removeParentCancelHandler();
		this._parent = value;
		this.parentCancelHandler = () => this.cancel();
		this._parent.onCancel(this.parentCancelHandler);
		}
		// babel cannot compile ... correctly for super calls
		constructor(parent) {
		super();
		this.parentCancelHandler = null;
		this._parent = null;
		this._cancelled = false;
		if (parent != null) {
		this.parent = parent;
		}
		}
		cancel() {
		this._cancelled = true;
		this.emit("cancel");
		}
		onCancel(handler) {
		if (this.cancelled) {
		handler();
		}
		else {
		this.once("cancel", handler);
		}
		}
		createPromise(callback) {
		if (this.cancelled) {
		return Promise.reject(new CancellationError());
		}
		const finallyHandler = () => {
		if (cancelHandler != null) {
		try {
		this.removeListener("cancel", cancelHandler);
		cancelHandler = null;
		}
		catch (_ignore) {
		// ignore
		}
		}
		};
		let cancelHandler = null;
		return new Promise((resolve, reject) => {
		let addedCancelHandler = null;
		cancelHandler = () => {
		try {
		if (addedCancelHandler != null) {
		addedCancelHandler();
		addedCancelHandler = null;
		}
		}
		finally {
		reject(new CancellationError());
		}
		};
		if (this.cancelled) {
		cancelHandler();
		return;
		}
		this.onCancel(cancelHandler);
		callback(resolve, reject, (callback) => {
		addedCancelHandler = callback;
		});
		})
		.then(it => {
		finallyHandler();
		return it;
		})
		.catch((e) => {
		finallyHandler();
		throw e;
		});
		}
		removeParentCancelHandler() {
		const parent = this._parent;
		if (parent != null && this.parentCancelHandler != null) {
		parent.removeListener("cancel", this.parentCancelHandler);
		this.parentCancelHandler = null;
		}
		}
		dispose() {
		try {
		this.removeParentCancelHandler();
		}
		finally {
		this.removeAllListeners();
		this._parent = null;
		}
		}
		}
		export class CancellationError extends Error {
		constructor() {
		super("cancelled");
		}
		}
		//# sourceMappingURL=CancellationToken.js.map

+1

dist/CancellationToken.js.map

+2

dist/error.d.ts

		export declare function newError(message: string, code: string): Error;
		//# sourceMappingURL=error.d.ts.map

+1

dist/error.d.ts.map

{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,SAIrD"}

+6

dist/error.js

		export function newError(message, code) {
		const error = new Error(message);
		error.code = code;
		return error;
		}
		//# sourceMappingURL=error.js.map

+1

dist/error.js.map

{"version":3,"file":"error.js","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,IAAY;IACpD,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAC/B;IAAC,KAA+B,CAAC,IAAI,GAAG,IAAI,CAAA;IAC7C,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["export function newError(message: string, code: string) {\n const error = new Error(message)\n ;(error as NodeJS.ErrnoException).code = code\n return error\n}\n"]}

+87

dist/httpExecutor.d.ts

		import { BinaryToTextEncoding } from "crypto";
		import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, RequestOptions } from "http";
		import { Transform } from "stream";
		import { URL } from "url";
		import { CancellationToken } from "./CancellationToken.js";
		import { ProgressInfo } from "./ProgressCallbackTransform.js";
		/**
		* Register an additional HTTP header to strip on cross-origin redirects.
		* Intended for custom publishers (e.g. GenericPublisher with a non-standard auth header).
		*/
		export declare function addSensitiveRedirectHeader(header: string): void;
		/**
		* Register an additional substring pattern used by {@link safeStringifyJson} to
		* identify sensitive field names. Input is normalized (lowercased, separators stripped).
		* Intended for custom publishers that store credentials under non-standard field names.
		*/
		export declare function addSensitiveFieldPattern(pattern: string): void;
		export interface RequestHeaders extends OutgoingHttpHeaders {
		[key: string]: OutgoingHttpHeader \| undefined;
		}
		export interface DownloadOptions {
		readonly headers?: OutgoingHttpHeaders \| null;
		readonly sha2?: string \| null;
		readonly sha512?: string \| null;
		readonly cancellationToken: CancellationToken;
		onProgress?: (progress: ProgressInfo) => void;
		}
		export declare function createHttpError(response: IncomingMessage, description?: any \| null): HttpError;
		export declare class HttpError extends Error {
		readonly statusCode: number;
		readonly description: any \| null;
		constructor(statusCode: number, message?: string, description?: any \| null);
		isServerError(): boolean;
		}
		export declare function parseJson(result: Promise<string \| null>): Promise<any>;
		interface Request {
		abort: () => void;
		end: (data?: Buffer) => void;
		}
		export declare abstract class HttpExecutor<T extends Request> {
		protected readonly maxRedirects = 10;
		request(options: RequestOptions, cancellationToken?: CancellationToken, data?: {
		[name: string]: any;
		} \| null): Promise<string \| null>;
		doApiRequest(options: RequestOptions, cancellationToken: CancellationToken, requestProcessor: (request: T, reject: (error: Error) => void) => void, redirectCount?: number): Promise<string>;
		protected addRedirectHandlers(request: any, options: RequestOptions, reject: (error: Error) => void, redirectCount: number, handler: (options: RequestOptions) => void): void;
		addErrorAndTimeoutHandlers(request: any, reject: (error: Error) => void, timeout?: number): void;
		private handleResponse;
		abstract createRequest(options: RequestOptions, callback: (response: any) => void): T;
		downloadToBuffer(url: URL, options: DownloadOptions): Promise<Buffer>;
		protected doDownload(requestOptions: RequestOptions, options: DownloadCallOptions, redirectCount: number): void;
		protected createMaxRedirectError(): Error;
		private addTimeOutHandler;
		static prepareRedirectUrlOptions(redirectUrl: string, options: RequestOptions): RequestOptions;
		private static reconstructOriginalUrl;
		private static isCrossOriginRedirect;
		static retryOnServerError(task: () => Promise<any>, maxRetries?: number): Promise<any>;
		}
		export interface DownloadCallOptions {
		responseHandler: ((response: IncomingMessage, callback: (error: Error \| null) => void) => void) \| null;
		onCancel: (callback: () => void) => void;
		callback: (error: Error \| null) => void;
		options: DownloadOptions;
		destination: string \| null;
		}
		export declare function configureRequestOptionsFromUrl(url: string, options: RequestOptions): RequestOptions;
		export declare function configureRequestUrl(url: URL, options: RequestOptions): void;
		export declare class DigestTransform extends Transform {
		readonly expected: string;
		private readonly algorithm;
		private readonly encoding;
		private readonly digester;
		private _actual;
		get actual(): string \| null;
		isValidateOnEnd: boolean;
		constructor(expected: string, algorithm?: string, encoding?: BinaryToTextEncoding);
		_transform(chunk: Buffer, encoding: string, callback: any): void;
		_flush(callback: any): void;
		validate(): null;
		}
		export declare function safeGetHeader(response: any, headerKey: string): any;
		export declare function configureRequestOptions(options: RequestOptions, token?: string \| null, method?: "GET" \| "DELETE" \| "PUT" \| "POST"): RequestOptions;
		export declare function isSensitiveFieldName(name: string): boolean;
		export declare function hashSensitiveValue(value: string): string;
		export declare function safeStringifyJson(data: any, skippedNames?: Set<string>): string;
		export {};
		//# sourceMappingURL=httpExecutor.d.ts.map

+1

dist/httpExecutor.d.ts.map

{"version":3,"file":"httpExecutor.d.ts","sourceRoot":"","sources":["../src/httpExecutor.ts"],"names":[],"mappings":"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"}

+512

dist/httpExecutor.js

		import { createHash } from "crypto";
		import { sleep } from "./retry.js";
		import _debug from "debug";
		import { createWriteStream } from "fs";
		import { Transform } from "stream";
		import { URL } from "url";
		import { CancellationToken } from "./CancellationToken.js";
		import { newError } from "./error.js";
		import { ProgressCallbackTransform } from "./ProgressCallbackTransform.js";
		const debug = _debug("electron-builder");
		// ── Sensitive-data registries ────────────────────────────────────────────────
		// Normalise a header or field name: lowercase + strip all separators (- and _).
		// Shared by both registries so lookup is always separator-agnostic.
		const normalizeName = (name) => name.toLowerCase().replace(/[-_]/g, "");
		// HTTP header names (normalised) stripped on cross-origin redirects.
		// Stored normalised; lookup normalises the incoming key with normalizeName().
		const SENSITIVE_REDIRECT_HEADERS = new Set(["authorization", "proxyauthorization", "privatetoken", "xapikey", "xauthtoken", "xaccesstoken", "xgitlabtoken", "cookie", "xcsrftoken"]);
		// Substrings: a field name containing any of these (after normalization) is redacted.
		const SENSITIVE_FIELD_PATTERNS = ["token", "password", "secret", "authorization", "credential", "apikey", "passphrase", "auth"];
		// Suffixes: a field name ending with any of these (after normalization) is redacted.
		// Intentionally greedy — "publicKey" is also stripped; over-stripping debug logs is
		// acceptable, under-stripping a credential is not.
		const SENSITIVE_FIELD_SUFFIXES = ["key"];
		/**
		* Register an additional HTTP header to strip on cross-origin redirects.
		* Intended for custom publishers (e.g. GenericPublisher with a non-standard auth header).
		*/
		export function addSensitiveRedirectHeader(header) {
		SENSITIVE_REDIRECT_HEADERS.add(normalizeName(header));
		}
		/**
		* Register an additional substring pattern used by {@link safeStringifyJson} to
		* identify sensitive field names. Input is normalized (lowercased, separators stripped).
		* Intended for custom publishers that store credentials under non-standard field names.
		*/
		export function addSensitiveFieldPattern(pattern) {
		SENSITIVE_FIELD_PATTERNS.push(pattern.toLowerCase().replace(/[-_]/g, ""));
		}
		export function createHttpError(response, description = null) {
		return new HttpError(response.statusCode \|\| -1, `${response.statusCode} ${response.statusMessage}` +
		(description == null ? "" : "\n" + JSON.stringify(description, null, " ")) +
		"\nHeaders: " +
		safeStringifyJson(response.headers), description);
		}
		const HTTP_STATUS_CODES = new Map([
		[429, "Too many requests"],
		[400, "Bad request"],
		[403, "Forbidden"],
		[404, "Not found"],
		[405, "Method not allowed"],
		[406, "Not acceptable"],
		[408, "Request timeout"],
		[413, "Request entity too large"],
		[500, "Internal server error"],
		[502, "Bad gateway"],
		[503, "Service unavailable"],
		[504, "Gateway timeout"],
		[505, "HTTP version not supported"],
		]);
		export class HttpError extends Error {
		constructor(statusCode, message = `HTTP error: ${HTTP_STATUS_CODES.get(statusCode) \|\| statusCode}`, description = null) {
		super(message);
		this.statusCode = statusCode;
		this.description = description;
		this.name = "HttpError";
		this.code = `HTTP_ERROR_${statusCode}`;
		}
		isServerError() {
		return this.statusCode >= 500 && this.statusCode <= 599;
		}
		}
		export function parseJson(result) {
		return result.then(it => (it == null \|\| it.length === 0 ? null : JSON.parse(it)));
		}
		export class HttpExecutor {
		constructor() {
		this.maxRedirects = 10;
		}
		request(options, cancellationToken = new CancellationToken(), data) {
		configureRequestOptions(options);
		const json = data == null ? undefined : JSON.stringify(data);
		const encodedData = json ? Buffer.from(json) : undefined;
		if (encodedData != null) {
		if (debug.enabled) {
		debug(safeStringifyJson(data));
		}
		const { headers, ...opts } = options;
		options = {
		method: "post",
		headers: {
		"Content-Type": "application/json",
		"Content-Length": encodedData.length,
		...headers,
		},
		...opts,
		};
		}
		return this.doApiRequest(options, cancellationToken, it => it.end(encodedData));
		}
		doApiRequest(options, cancellationToken, requestProcessor, redirectCount = 0) {
		if (debug.enabled) {
		const { headers: _headers, auth: _auth, ...safeOptions } = options;
		debug(`Request: ${safeStringifyJson(safeOptions)}`);
		}
		return cancellationToken.createPromise((resolve, reject, onCancel) => {
		const request = this.createRequest(options, (response) => {
		try {
		this.handleResponse(response, options, cancellationToken, resolve, reject, redirectCount, requestProcessor);
		}
		catch (e) {
		reject(e);
		}
		});
		this.addErrorAndTimeoutHandlers(request, reject, options.timeout);
		this.addRedirectHandlers(request, options, reject, redirectCount, options => {
		this.doApiRequest(options, cancellationToken, requestProcessor, redirectCount).then(resolve).catch(reject);
		});
		requestProcessor(request, reject);
		onCancel(() => request.abort());
		});
		}
		// noinspection JSUnusedLocalSymbols
		// eslint-disable-next-line
		addRedirectHandlers(request, options, reject, redirectCount, handler) {
		// not required for NodeJS
		}
		addErrorAndTimeoutHandlers(request, reject, timeout = 60 * 1000) {
		this.addTimeOutHandler(request, reject, timeout);
		request.on("error", reject);
		request.on("aborted", () => {
		reject(new Error("Request has been aborted by the server"));
		});
		}
		handleResponse(response, options, cancellationToken, resolve, reject, redirectCount, requestProcessor) {
		if (debug.enabled) {
		const { headers: _headers, auth: _auth, ...safeOptions } = options;
		debug(`Response: ${response.statusCode} ${response.statusMessage}, request options: ${safeStringifyJson(safeOptions)}`);
		}
		// we handle any other >= 400 error on request end (read detailed message in the response body)
		if (response.statusCode === 404) {
		// error is clear, we don't need to read detailed error description
		reject(createHttpError(response, `method: ${options.method \|\| "GET"} url: ${options.protocol \|\| "https:"}//${options.hostname}${options.port ? `:${options.port}` : ""}${options.path}

		Please double check that your authentication token is correct. Due to security reasons, actual status maybe not reported, but 404.
		`));
		return;
		}
		else if (response.statusCode === 204) {
		// on DELETE request
		resolve();
		return;
		}
		const code = response.statusCode ?? 0;
		const shouldRedirect = code >= 300 && code < 400;
		const redirectUrl = safeGetHeader(response, "location");
		if (shouldRedirect && redirectUrl != null) {
		if (redirectCount > this.maxRedirects) {
		reject(this.createMaxRedirectError());
		return;
		}
		this.doApiRequest(HttpExecutor.prepareRedirectUrlOptions(redirectUrl, options), cancellationToken, requestProcessor, redirectCount).then(resolve).catch(reject);
		return;
		}
		response.setEncoding("utf8");
		let data = "";
		response.on("error", reject);
		response.on("data", (chunk) => (data += chunk));
		response.on("end", () => {
		try {
		if (response.statusCode != null && response.statusCode >= 400) {
		const contentType = safeGetHeader(response, "content-type");
		const isJson = contentType != null && (Array.isArray(contentType) ? contentType.find(it => it.includes("json")) != null : contentType.includes("json"));
		reject(createHttpError(response, `method: ${options.method \|\| "GET"} url: ${options.protocol \|\| "https:"}//${options.hostname}${options.port ? `:${options.port}` : ""}${options.path}

		Data:
		${isJson ? safeStringifyJson(JSON.parse(data)) : data}
		`));
		}
		else {
		resolve(data.length === 0 ? null : data);
		}
		}
		catch (e) {
		reject(e);
		}
		});
		}
		async downloadToBuffer(url, options) {
		return await options.cancellationToken.createPromise((resolve, reject, onCancel) => {
		const responseChunks = [];
		const requestOptions = {
		headers: options.headers \|\| undefined,
		// because PrivateGitHubProvider requires HttpExecutor.prepareRedirectUrlOptions logic, so, we need to redirect manually
		redirect: "manual",
		};
		configureRequestUrl(url, requestOptions);
		configureRequestOptions(requestOptions);
		this.doDownload(requestOptions, {
		destination: null,
		options,
		onCancel,
		callback: error => {
		if (error == null) {
		resolve(Buffer.concat(responseChunks));
		}
		else {
		reject(error);
		}
		},
		responseHandler: (response, callback) => {
		let receivedLength = 0;
		response.on("data", (chunk) => {
		receivedLength += chunk.length;
		if (receivedLength > 524288000) {
		callback(new Error("Maximum allowed size is 500 MB"));
		return;
		}
		responseChunks.push(chunk);
		});
		response.on("end", () => {
		callback(null);
		});
		},
		}, 0);
		});
		}
		doDownload(requestOptions, options, redirectCount) {
		const request = this.createRequest(requestOptions, (response) => {
		if (response.statusCode >= 400) {
		options.callback(new Error(`Cannot download "${requestOptions.protocol \|\| "https:"}//${requestOptions.hostname}${requestOptions.path}", status ${response.statusCode}: ${response.statusMessage}`));
		return;
		}
		// It is possible for the response stream to fail, e.g. when a network is lost while
		// response stream is in progress. Stop waiting and reject so consumer can catch the error.
		response.on("error", options.callback);
		// this code not relevant for Electron (redirect event instead handled)
		const redirectUrl = safeGetHeader(response, "location");
		if (redirectUrl != null) {
		if (redirectCount < this.maxRedirects) {
		this.doDownload(HttpExecutor.prepareRedirectUrlOptions(redirectUrl, requestOptions), options, redirectCount++);
		}
		else {
		options.callback(this.createMaxRedirectError());
		}
		return;
		}
		if (options.responseHandler == null) {
		configurePipes(options, response);
		}
		else {
		options.responseHandler(response, options.callback);
		}
		});
		this.addErrorAndTimeoutHandlers(request, options.callback, requestOptions.timeout);
		this.addRedirectHandlers(request, requestOptions, options.callback, redirectCount, requestOptions => {
		this.doDownload(requestOptions, options, redirectCount++);
		});
		request.end();
		}
		createMaxRedirectError() {
		return new Error(`Too many redirects (> ${this.maxRedirects})`);
		}
		addTimeOutHandler(request, callback, timeout) {
		request.on("socket", (socket) => {
		socket.setTimeout(timeout, () => {
		request.abort();
		callback(new Error("Request timed out"));
		});
		});
		}
		static prepareRedirectUrlOptions(redirectUrl, options) {
		const newOptions = configureRequestOptionsFromUrl(redirectUrl, { ...options });
		const headers = newOptions.headers;
		if (headers == null) {
		return newOptions;
		}
		const originalUrl = HttpExecutor.reconstructOriginalUrl(options);
		const parsedRedirectUrl = parseUrl(redirectUrl, options);
		if (HttpExecutor.isCrossOriginRedirect(originalUrl, parsedRedirectUrl)) {
		if (debug.enabled) {
		debug(`Cross-origin redirect (${originalUrl.host} → ${parsedRedirectUrl.host}): stripping sensitive headers`);
		}
		for (const key of Object.keys(headers)) {
		if (SENSITIVE_REDIRECT_HEADERS.has(normalizeName(key))) {
		delete headers[key];
		}
		}
		}
		return newOptions;
		}
		static reconstructOriginalUrl(options) {
		const protocol = options.protocol \|\| "https:";
		if (!options.hostname) {
		throw new Error("Missing hostname in request options");
		}
		const hostname = options.hostname;
		const port = options.port ? `:${options.port}` : "";
		const path = options.path \|\| "/";
		return new URL(`${protocol}//${hostname}${port}${path}`);
		}
		static isCrossOriginRedirect(originalUrl, redirectUrl) {
		// Case-insensitive hostname comparison
		if (originalUrl.hostname.toLowerCase() !== redirectUrl.hostname.toLowerCase()) {
		return true;
		}
		// Special case: allow http -> https redirect on same host with standard ports
		// This matches the behavior of Python requests library for backward compatibility
		// url.port returns an empty string if the port is omitted
		// or explicitly set to the default port for a given protocol.
		if (originalUrl.protocol === "http:" &&
		// This can be replaced with `!originalUrl.port`, but for the sake of clarity.
		["80", ""].includes(originalUrl.port) &&
		redirectUrl.protocol === "https:" &&
		// This can be replaced with `!redirectUrl.port`, but for the sake of clarity.
		["443", ""].includes(redirectUrl.port)) {
		return false;
		}
		// According to RFC 7235, a change in protocol or port constitutes a cross-origin request.
		// Forwarding authentication headers to a different origin can be a security risk.
		// For example, https://example.com:443 and http://example.com:80 are different origins.
		// We only make an exception for HTTP -> HTTPS upgrades on standard ports for backward compatibility.
		// Strip auth on any other protocol change
		if (originalUrl.protocol !== redirectUrl.protocol) {
		return true;
		}
		// Strip auth on port change (accounting for default ports)
		const originalPort = originalUrl.port;
		const redirectPort = redirectUrl.port;
		return originalPort !== redirectPort;
		}
		static async retryOnServerError(task, maxRetries = 3) {
		for (let attemptNumber = 0;; attemptNumber++) {
		try {
		return await task();
		}
		catch (e) {
		if (attemptNumber < maxRetries && ((e instanceof HttpError && e.isServerError()) \|\| e.code === "EPIPE")) {
		await sleep(1000 * (attemptNumber + 1));
		continue;
		}
		throw e;
		}
		}
		}
		}
		function parseUrl(url, options) {
		try {
		// Would throw exception if url is not absolute
		return new URL(url);
		}
		catch {
		// Relative URL - construct base URL from original options
		const hostname = options.hostname;
		const protocol = options.protocol \|\| "https:";
		const port = options.port ? `:${options.port}` : "";
		const baseUrl = `${protocol}//${hostname}${port}`;
		return new URL(url, baseUrl);
		}
		}
		export function configureRequestOptionsFromUrl(url, options) {
		const result = configureRequestOptions(options);
		const parsedUrl = parseUrl(url, options);
		configureRequestUrl(parsedUrl, result);
		return result;
		}
		export function configureRequestUrl(url, options) {
		options.protocol = url.protocol;
		options.hostname = url.hostname;
		if (url.port) {
		options.port = url.port;
		}
		else if (options.port) {
		delete options.port;
		}
		options.path = url.pathname + url.search;
		}
		export class DigestTransform extends Transform {
		// noinspection JSUnusedGlobalSymbols
		get actual() {
		return this._actual;
		}
		constructor(expected, algorithm = "sha512", encoding = "base64") {
		super();
		this.expected = expected;
		this.algorithm = algorithm;
		this.encoding = encoding;
		this._actual = null;
		this.isValidateOnEnd = true;
		this.digester = createHash(algorithm);
		}
		// noinspection JSUnusedGlobalSymbols
		_transform(chunk, encoding, callback) {
		this.digester.update(chunk);
		callback(null, chunk);
		}
		// noinspection JSUnusedGlobalSymbols
		_flush(callback) {
		this._actual = this.digester.digest(this.encoding);
		if (this.isValidateOnEnd) {
		try {
		this.validate();
		}
		catch (e) {
		callback(e);
		return;
		}
		}
		callback(null);
		}
		validate() {
		if (this._actual == null) {
		throw newError("Not finished yet", "ERR_STREAM_NOT_FINISHED");
		}
		if (this._actual !== this.expected) {
		throw newError(`${this.algorithm} checksum mismatch, expected ${this.expected}, got ${this._actual}`, "ERR_CHECKSUM_MISMATCH");
		}
		return null;
		}
		}
		function checkSha2(sha2Header, sha2, callback) {
		if (sha2Header != null && sha2 != null && sha2Header !== sha2) {
		callback(new Error(`checksum mismatch: expected ${sha2} but got ${sha2Header} (X-Checksum-Sha2 header)`));
		return false;
		}
		return true;
		}
		export function safeGetHeader(response, headerKey) {
		const value = response.headers[headerKey];
		if (value == null) {
		return null;
		}
		else if (Array.isArray(value)) {
		// electron API
		return value.length === 0 ? null : value[value.length - 1];
		}
		else {
		return value;
		}
		}
		function configurePipes(options, response) {
		if (!checkSha2(safeGetHeader(response, "X-Checksum-Sha2"), options.options.sha2, options.callback)) {
		return;
		}
		const streams = [];
		if (options.options.onProgress != null) {
		const contentLength = safeGetHeader(response, "content-length");
		if (contentLength != null) {
		streams.push(new ProgressCallbackTransform(parseInt(contentLength, 10), options.options.cancellationToken, options.options.onProgress));
		}
		}
		const sha512 = options.options.sha512;
		if (sha512 != null) {
		streams.push(new DigestTransform(sha512, "sha512", sha512.length === 128 && !sha512.includes("+") && !sha512.includes("Z") && !sha512.includes("=") ? "hex" : "base64"));
		}
		else if (options.options.sha2 != null) {
		streams.push(new DigestTransform(options.options.sha2, "sha256", "hex"));
		}
		const fileOut = createWriteStream(options.destination);
		streams.push(fileOut);
		let lastStream = response;
		for (const stream of streams) {
		stream.on("error", (error) => {
		fileOut.close();
		if (!options.options.cancellationToken.cancelled) {
		options.callback(error);
		}
		});
		lastStream = lastStream.pipe(stream);
		}
		fileOut.on("finish", () => {
		;
		fileOut.close(options.callback);
		});
		}
		export function configureRequestOptions(options, token, method) {
		if (method != null) {
		options.method = method;
		}
		options.headers = { ...options.headers };
		const headers = options.headers;
		if (token != null) {
		;
		headers.authorization = token.startsWith("Basic") \|\| token.startsWith("Bearer") ? token : `token ${token}`;
		}
		if (headers["User-Agent"] == null) {
		headers["User-Agent"] = "electron-builder";
		}
		if (method == null \|\| method === "GET" \|\| headers["Cache-Control"] == null) {
		headers["Cache-Control"] = "no-cache";
		}
		// do not specify for node (in any case we use https module)
		if (options.protocol == null && process.versions.electron != null) {
		options.protocol = "https:";
		}
		return options;
		}
		export function isSensitiveFieldName(name) {
		const normalized = normalizeName(name);
		return SENSITIVE_FIELD_PATTERNS.some(p => normalized.includes(p)) \|\| SENSITIVE_FIELD_SUFFIXES.some(s => normalized.endsWith(s));
		}
		export function hashSensitiveValue(value) {
		return `${createHash("sha256").update(value).digest("hex")} (sha256 hash)`;
		}
		export function safeStringifyJson(data, skippedNames) {
		return JSON.stringify(data, (name, value) => {
		if (isSensitiveFieldName(name) \|\| (skippedNames != null && skippedNames.has(name))) {
		return typeof value === "string" ? hashSensitiveValue(value) : "<stripped sensitive data>";
		}
		return value;
		}, 2);
		}
		//# sourceMappingURL=httpExecutor.js.map

+1

dist/httpExecutor.js.map

+16

dist/index.d.ts

		export { BlockMap } from "./blockMapApi.js";
		export { CancellationError, CancellationToken } from "./CancellationToken.js";
		export { newError } from "./error.js";
		export { configureRequestOptions, configureRequestOptionsFromUrl, configureRequestUrl, createHttpError, DigestTransform, DownloadOptions, HttpError, hashSensitiveValue, HttpExecutor, isSensitiveFieldName, parseJson, RequestHeaders, safeGetHeader, safeStringifyJson, } from "./httpExecutor.js";
		export { MemoLazy } from "./MemoLazy.js";
		export { ProgressCallbackTransform, ProgressInfo } from "./ProgressCallbackTransform.js";
		export { AllPublishOptions, BaseS3Options, BitbucketOptions, CustomPublishOptions, GenericServerOptions, getS3LikeProviderBaseUrl, GithubOptions, githubUrl, githubTagPrefix, GitlabOptions, KeygenOptions, PublishConfiguration, PublishProvider, S3Options, SnapStoreOptions, SpacesOptions, GitlabReleaseInfo, GitlabReleaseAsset, } from "./publishOptions.js";
		export { retry, sleep } from "./retry.js";
		export { parseDn } from "./rfc2253Parser.js";
		export { BlockMapDataHolder, PackageFileInfo, ReleaseNoteInfo, UpdateFileInfo, UpdateInfo, WindowsUpdateInfo } from "./updateInfo.js";
		export { UUID } from "./uuid.js";
		export { parseXml, XElement } from "./xml.js";
		export { isValidKey, mapToObject, asArray, Nullish, deepAssign, objectToArgs } from "./objects.js";
		export declare const CURRENT_APP_INSTALLER_FILE_NAME = "installer.exe";
		export declare const CURRENT_APP_PACKAGE_FILE_NAME = "package.7z";
		//# sourceMappingURL=index.d.ts.map

+1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC7E,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,eAAe,EACf,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACpB,SAAS,EACT,cAAc,EACd,aAAa,EACb,iBAAiB,GAClB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,yBAAyB,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AACxF,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,aAAa,EACb,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,eAAe,EACf,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACrI,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGlG,eAAO,MAAM,+BAA+B,kBAAkB,CAAA;AAE9D,eAAO,MAAM,6BAA6B,eAAe,CAAA"}

+16

dist/index.js

		export { CancellationError, CancellationToken } from "./CancellationToken.js";
		export { newError } from "./error.js";
		export { configureRequestOptions, configureRequestOptionsFromUrl, configureRequestUrl, createHttpError, DigestTransform, HttpError, hashSensitiveValue, HttpExecutor, isSensitiveFieldName, parseJson, safeGetHeader, safeStringifyJson, } from "./httpExecutor.js";
		export { MemoLazy } from "./MemoLazy.js";
		export { ProgressCallbackTransform } from "./ProgressCallbackTransform.js";
		export { getS3LikeProviderBaseUrl, githubUrl, githubTagPrefix, } from "./publishOptions.js";
		export { retry, sleep } from "./retry.js";
		export { parseDn } from "./rfc2253Parser.js";
		export { UUID } from "./uuid.js";
		export { parseXml, XElement } from "./xml.js";
		export { isValidKey, mapToObject, asArray, deepAssign, objectToArgs } from "./objects.js";
		// nsis
		export const CURRENT_APP_INSTALLER_FILE_NAME = "installer.exe";
		// nsis-web
		export const CURRENT_APP_PACKAGE_FILE_NAME = "package.7z";
		//# sourceMappingURL=index.js.map

+1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC7E,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,mBAAmB,EACnB,eAAe,EACf,eAAe,EAEf,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACpB,SAAS,EAET,aAAa,EACb,iBAAiB,GAClB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,yBAAyB,EAAgB,MAAM,gCAAgC,CAAA;AACxF,OAAO,EAML,wBAAwB,EAExB,SAAS,EACT,eAAe,GAUhB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAE5C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAW,UAAU,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAElG,OAAO;AACP,MAAM,CAAC,MAAM,+BAA+B,GAAG,eAAe,CAAA;AAC9D,WAAW;AACX,MAAM,CAAC,MAAM,6BAA6B,GAAG,YAAY,CAAA","sourcesContent":["export { BlockMap } from \"./blockMapApi.js\"\nexport { CancellationError, CancellationToken } from \"./CancellationToken.js\"\nexport { newError } from \"./error.js\"\nexport {\n configureRequestOptions,\n configureRequestOptionsFromUrl,\n configureRequestUrl,\n createHttpError,\n DigestTransform,\n DownloadOptions,\n HttpError,\n hashSensitiveValue,\n HttpExecutor,\n isSensitiveFieldName,\n parseJson,\n RequestHeaders,\n safeGetHeader,\n safeStringifyJson,\n} from \"./httpExecutor.js\"\nexport { MemoLazy } from \"./MemoLazy.js\"\nexport { ProgressCallbackTransform, ProgressInfo } from \"./ProgressCallbackTransform.js\"\nexport {\n AllPublishOptions,\n BaseS3Options,\n BitbucketOptions,\n CustomPublishOptions,\n GenericServerOptions,\n getS3LikeProviderBaseUrl,\n GithubOptions,\n githubUrl,\n githubTagPrefix,\n GitlabOptions,\n KeygenOptions,\n PublishConfiguration,\n PublishProvider,\n S3Options,\n SnapStoreOptions,\n SpacesOptions,\n GitlabReleaseInfo,\n GitlabReleaseAsset,\n} from \"./publishOptions.js\"\nexport { retry, sleep } from \"./retry.js\"\nexport { parseDn } from \"./rfc2253Parser.js\"\nexport { BlockMapDataHolder, PackageFileInfo, ReleaseNoteInfo, UpdateFileInfo, UpdateInfo, WindowsUpdateInfo } from \"./updateInfo.js\"\nexport { UUID } from \"./uuid.js\"\nexport { parseXml, XElement } from \"./xml.js\"\nexport { isValidKey, mapToObject, asArray, Nullish, deepAssign, objectToArgs } from \"./objects.js\"\n\n// nsis\nexport const CURRENT_APP_INSTALLER_FILE_NAME = \"installer.exe\"\n// nsis-web\nexport const CURRENT_APP_PACKAGE_FILE_NAME = \"package.7z\"\n"]}

+4

dist/indexInternal.d.ts

		export { BlockMap, BlockMapFile } from "./blockMapApi.js";
		export { hashSensitiveValue, safeStringifyJson } from "./httpExecutor.js";
		export type { SnapStoreOptions } from "./publishOptions.js";
		//# sourceMappingURL=indexInternal.d.ts.map

+1

dist/indexInternal.d.ts.map

{"version":3,"file":"indexInternal.d.ts","sourceRoot":"","sources":["../src/indexInternal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA"}

+2

dist/indexInternal.js

		export { hashSensitiveValue, safeStringifyJson } from "./httpExecutor.js";
		//# sourceMappingURL=indexInternal.js.map

+1

dist/indexInternal.js.map

{"version":3,"file":"indexInternal.js","sourceRoot":"","sources":["../src/indexInternal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA","sourcesContent":["export { BlockMap, BlockMapFile } from \"./blockMapApi.js\"\nexport { hashSensitiveValue, safeStringifyJson } from \"./httpExecutor.js\"\nexport type { SnapStoreOptions } from \"./publishOptions.js\"\n"]}

+11

dist/MemoLazy.d.ts

		export declare class MemoLazy<S, V> {
		private selector;
		private creator;
		private selected;
		private _value;
		constructor(selector: () => S, creator: (selected: S) => Promise<V>);
		get hasValue(): boolean;
		get value(): Promise<V>;
		set value(value: Promise<V>);
		}
		//# sourceMappingURL=MemoLazy.d.ts.map

+1

dist/MemoLazy.d.ts.map

{"version":3,"file":"MemoLazy.d.ts","sourceRoot":"","sources":["../src/MemoLazy.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC;IAKtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IALjB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,MAAM,CAAoC;gBAGxC,QAAQ,EAAE,MAAM,CAAC,EACjB,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;IAG9C,IAAI,QAAQ,YAEX;IAED,IAAI,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EAE1B;CACF"}

+38

dist/MemoLazy.js

		export class MemoLazy {
		constructor(selector, creator) {
		this.selector = selector;
		this.creator = creator;
		this.selected = undefined;
		this._value = undefined;
		}
		get hasValue() {
		return this._value !== undefined;
		}
		get value() {
		const selected = this.selector();
		if (this._value !== undefined && equals(this.selected, selected)) {
		// value exists and selected hasn't changed, so return the cached value
		return this._value;
		}
		this.selected = selected;
		const result = this.creator(selected);
		this.value = result;
		return result;
		}
		set value(value) {
		this._value = value;
		}
		}
		function equals(firstValue, secondValue) {
		const isFirstObject = typeof firstValue === "object" && firstValue !== null;
		const isSecondObject = typeof secondValue === "object" && secondValue !== null;
		// do a shallow comparison of objects, arrays etc.
		if (isFirstObject && isSecondObject) {
		const keys1 = Object.keys(firstValue);
		const keys2 = Object.keys(secondValue);
		return keys1.length === keys2.length && keys1.every((key) => equals(firstValue[key], secondValue[key]));
		}
		// otherwise just compare the values directly
		return firstValue === secondValue;
		}
		//# sourceMappingURL=MemoLazy.js.map

+1

dist/MemoLazy.js.map

{"version":3,"file":"MemoLazy.js","sourceRoot":"","sources":["../src/MemoLazy.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,QAAQ;IAInB,YACU,QAAiB,EACjB,OAAoC;QADpC,aAAQ,GAAR,QAAQ,CAAS;QACjB,YAAO,GAAP,OAAO,CAA6B;QALtC,aAAQ,GAAkB,SAAS,CAAA;QACnC,WAAM,GAA2B,SAAS,CAAA;IAK/C,CAAC;IAEJ,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,CAAA;IAClC,CAAC;IAED,IAAI,KAAK;QACP,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAA;QAChC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC;YACjE,uEAAuE;YACvE,OAAO,IAAI,CAAC,MAAM,CAAA;QACpB,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;QACrC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAA;QAEnB,OAAO,MAAM,CAAA;IACf,CAAC;IAED,IAAI,KAAK,CAAC,KAAiB;QACzB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;IACrB,CAAC;CACF;AAED,SAAS,MAAM,CAAC,UAAe,EAAE,WAAgB;IAC/C,MAAM,aAAa,GAAG,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,IAAI,CAAA;IAC3E,MAAM,cAAc,GAAG,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,IAAI,CAAA;IAE9E,kDAAkD;IAClD,IAAI,aAAa,IAAI,cAAc,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QACrC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAEtC,OAAO,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IAC9G,CAAC;IAED,6CAA6C;IAC7C,OAAO,UAAU,KAAK,WAAW,CAAA;AACnC,CAAC","sourcesContent":["export class MemoLazy<S, V> {\n private selected: S | undefined = undefined\n private _value: Promise<V> | undefined = undefined\n\n constructor(\n private selector: () => S,\n private creator: (selected: S) => Promise<V>\n ) {}\n\n get hasValue() {\n return this._value !== undefined\n }\n\n get value(): Promise<V> {\n const selected = this.selector()\n if (this._value !== undefined && equals(this.selected, selected)) {\n // value exists and selected hasn't changed, so return the cached value\n return this._value\n }\n\n this.selected = selected\n const result = this.creator(selected)\n this.value = result\n\n return result\n }\n\n set value(value: Promise<V>) {\n this._value = value\n }\n}\n\nfunction equals(firstValue: any, secondValue: any): boolean {\n const isFirstObject = typeof firstValue === \"object\" && firstValue !== null\n const isSecondObject = typeof secondValue === \"object\" && secondValue !== null\n\n // do a shallow comparison of objects, arrays etc.\n if (isFirstObject && isSecondObject) {\n const keys1 = Object.keys(firstValue)\n const keys2 = Object.keys(secondValue)\n\n return keys1.length === keys2.length && keys1.every((key: any) => equals(firstValue[key], secondValue[key]))\n }\n\n // otherwise just compare the values directly\n return firstValue === secondValue\n}\n"]}

+9

dist/objects.d.ts

		export type Nullish = null \| undefined;
		type RecursiveMap = Map<any, RecursiveMap \| any>;
		export declare function mapToObject(map: RecursiveMap): any;
		export declare function isValidKey(key: any): boolean;
		export declare function asArray<T>(v: Nullish \| T \| Array<T>): Array<T>;
		export declare function deepAssign<T>(target: T, ...objects: Array<any>): T;
		export declare function objectToArgs(obj: Record<string, string \| null>): readonly string[];
		export {};
		//# sourceMappingURL=objects.d.ts.map

+1

dist/objects.d.ts.map

{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../src/objects.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,IAAI,GAAG,SAAS,CAAA;AAEtC,KAAK,YAAY,GAAG,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,GAAG,CAAC,CAAA;AAEhD,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,OAa5C;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,WAMlC;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAQ9D;AA0CD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAOlE;AASD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,SAAS,MAAM,EAAE,CAclF"}

+99

dist/objects.js

		export function mapToObject(map) {
		const obj = {};
		for (const [key, value] of map) {
		if (!isValidKey(key)) {
		continue;
		}
		if (value instanceof Map) {
		obj[key] = mapToObject(value);
		}
		else {
		obj[key] = value;
		}
		}
		return obj;
		}
		export function isValidKey(key) {
		const protectedProperties = ["__proto__", "prototype", "constructor"];
		if (protectedProperties.includes(key)) {
		return false;
		}
		return ["string", "number", "symbol", "boolean"].includes(typeof key) \|\| key === null;
		}
		export function asArray(v) {
		if (v == null) {
		return [];
		}
		else if (Array.isArray(v)) {
		return v;
		}
		else {
		return [v];
		}
		}
		function isObject(x) {
		if (Array.isArray(x)) {
		return false;
		}
		const type = typeof x;
		return type === "object" \|\| type === "function";
		}
		function assignKey(target, from, key) {
		const value = from[key];
		// https://github.com/electron-userland/electron-builder/pull/562
		if (value === undefined) {
		return;
		}
		const prevValue = target[key];
		if (prevValue == null \|\| value == null \|\| !isObject(prevValue) \|\| !isObject(value)) {
		// Merge arrays.
		if (Array.isArray(prevValue) && Array.isArray(value)) {
		target[key] = Array.from(new Set(prevValue.concat(value)));
		}
		else {
		target[key] = value;
		}
		}
		else {
		target[key] = assign(prevValue, value);
		}
		}
		function assign(to, from) {
		if (to !== from) {
		for (const key of Object.getOwnPropertyNames(from)) {
		if (isValidKey(key)) {
		assignKey(to, from, key);
		}
		}
		}
		return to;
		}
		export function deepAssign(target, ...objects) {
		for (const o of objects) {
		if (o != null) {
		assign(target, o);
		}
		}
		return target;
		}
		// Flag names must be letters/digits/hyphens only (e.g. "maintainer", "deb-priority").
		// Anything else could inject extra flags into the argument array.
		const SAFE_FLAG_NAME_RE = /^[a-zA-Z][a-zA-Z0-9-]*$/;
		// Null bytes truncate arguments at the C layer; newlines can split arguments in some parsers.
		const UNSAFE_VALUE_RE = /[\0\r\n]/;
		export function objectToArgs(obj) {
		const args = Object.entries(obj).reduce((args, [name, value]) => {
		if (!isValidKey(name) \|\| value == null) {
		return args;
		}
		if (!SAFE_FLAG_NAME_RE.test(name)) {
		throw new Error(`objectToArgs: unsafe flag name rejected: ${JSON.stringify(name)}`);
		}
		if (UNSAFE_VALUE_RE.test(value)) {
		throw new Error(`objectToArgs: value for --${name} contains a null byte or newline`);
		}
		return args.concat([`--${name}`, value]);
		}, []);
		return Object.freeze(args);
		}
		//# sourceMappingURL=objects.js.map

+1

dist/objects.js.map

+22

dist/ProgressCallbackTransform.d.ts

		import { Transform } from "stream";
		import { CancellationToken } from "./CancellationToken.js";
		export interface ProgressInfo {
		total: number;
		delta: number;
		transferred: number;
		percent: number;
		bytesPerSecond: number;
		}
		export declare class ProgressCallbackTransform extends Transform {
		private readonly total;
		private readonly cancellationToken;
		private readonly onProgress;
		private start;
		private transferred;
		private delta;
		private nextUpdate;
		constructor(total: number, cancellationToken: CancellationToken, onProgress: (info: ProgressInfo) => any);
		_transform(chunk: any, encoding: string, callback: any): void;
		_flush(callback: any): void;
		}
		//# sourceMappingURL=ProgressCallbackTransform.d.ts.map

+1

dist/ProgressCallbackTransform.d.ts.map

{"version":3,"file":"ProgressCallbackTransform.d.ts","sourceRoot":"","sources":["../src/ProgressCallbackTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE1D,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,qBAAa,yBAA0B,SAAQ,SAAS;IAQpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAT7B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,WAAW,CAAI;IACvB,OAAO,CAAC,KAAK,CAAI;IAEjB,OAAO,CAAC,UAAU,CAAoB;gBAGnB,KAAK,EAAE,MAAM,EACb,iBAAiB,EAAE,iBAAiB,EACpC,UAAU,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,GAAG;IAK1D,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG;IA0BtD,MAAM,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;CAiB5B"}

+50

dist/ProgressCallbackTransform.js

		import { Transform } from "stream";
		export class ProgressCallbackTransform extends Transform {
		constructor(total, cancellationToken, onProgress) {
		super();
		this.total = total;
		this.cancellationToken = cancellationToken;
		this.onProgress = onProgress;
		this.start = Date.now();
		this.transferred = 0;
		this.delta = 0;
		this.nextUpdate = this.start + 1000;
		}
		_transform(chunk, encoding, callback) {
		if (this.cancellationToken.cancelled) {
		callback(new Error("cancelled"), null);
		return;
		}
		this.transferred += chunk.length;
		this.delta += chunk.length;
		const now = Date.now();
		if (now >= this.nextUpdate && this.transferred !== this.total /* will be emitted on _flush */) {
		this.nextUpdate = now + 1000;
		this.onProgress({
		total: this.total,
		delta: this.delta,
		transferred: this.transferred,
		percent: (this.transferred / this.total) * 100,
		bytesPerSecond: Math.round(this.transferred / ((now - this.start) / 1000)),
		});
		this.delta = 0;
		}
		callback(null, chunk);
		}
		_flush(callback) {
		if (this.cancellationToken.cancelled) {
		callback(new Error("cancelled"));
		return;
		}
		this.onProgress({
		total: this.total,
		delta: this.delta,
		transferred: this.total,
		percent: 100,
		bytesPerSecond: Math.round(this.transferred / ((Date.now() - this.start) / 1000)),
		});
		this.delta = 0;
		callback(null);
		}
		}
		//# sourceMappingURL=ProgressCallbackTransform.js.map

+1

dist/ProgressCallbackTransform.js.map

{"version":3,"file":"ProgressCallbackTransform.js","sourceRoot":"","sources":["../src/ProgressCallbackTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAWlC,MAAM,OAAO,yBAA0B,SAAQ,SAAS;IAOtD,YACmB,KAAa,EACb,iBAAoC,EACpC,UAAuC;QAExD,KAAK,EAAE,CAAA;QAJU,UAAK,GAAL,KAAK,CAAQ;QACb,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,eAAU,GAAV,UAAU,CAA6B;QATlD,UAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QAClB,gBAAW,GAAG,CAAC,CAAA;QACf,UAAK,GAAG,CAAC,CAAA;QAET,eAAU,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IAQtC,CAAC;IAED,UAAU,CAAC,KAAU,EAAE,QAAgB,EAAE,QAAa;QACpD,IAAI,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YACrC,QAAQ,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAA;YACtC,OAAM;QACR,CAAC;QAED,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,MAAM,CAAA;QAChC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,CAAA;QAE1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QACtB,IAAI,GAAG,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,KAAK,CAAC,+BAA+B,EAAE,CAAC;YAC9F,IAAI,CAAC,UAAU,GAAG,GAAG,GAAG,IAAI,CAAA;YAE5B,IAAI,CAAC,UAAU,CAAC;gBACd,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,OAAO,EAAE,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG;gBAC9C,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;aAC3E,CAAC,CAAA;YACF,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QAChB,CAAC;QAED,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IACvB,CAAC;IAED,MAAM,CAAC,QAAa;QAClB,IAAI,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YACrC,QAAQ,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,CAAA;YAChC,OAAM;QACR,CAAC;QAED,IAAI,CAAC,UAAU,CAAC;YACd,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,KAAK;YACvB,OAAO,EAAE,GAAG;YACZ,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;SAClF,CAAC,CAAA;QACF,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QAEd,QAAQ,CAAC,IAAI,CAAC,CAAA;IAChB,CAAC;CACF","sourcesContent":["import { Transform } from \"stream\"\nimport { CancellationToken } from \"./CancellationToken.js\"\n\nexport interface ProgressInfo {\n total: number\n delta: number\n transferred: number\n percent: number\n bytesPerSecond: number\n}\n\nexport class ProgressCallbackTransform extends Transform {\n private start = Date.now()\n private transferred = 0\n private delta = 0\n\n private nextUpdate = this.start + 1000\n\n constructor(\n private readonly total: number,\n private readonly cancellationToken: CancellationToken,\n private readonly onProgress: (info: ProgressInfo) => any\n ) {\n super()\n }\n\n _transform(chunk: any, encoding: string, callback: any) {\n if (this.cancellationToken.cancelled) {\n callback(new Error(\"cancelled\"), null)\n return\n }\n\n this.transferred += chunk.length\n this.delta += chunk.length\n\n const now = Date.now()\n if (now >= this.nextUpdate && this.transferred !== this.total /* will be emitted on _flush */) {\n this.nextUpdate = now + 1000\n\n this.onProgress({\n total: this.total,\n delta: this.delta,\n transferred: this.transferred,\n percent: (this.transferred / this.total) * 100,\n bytesPerSecond: Math.round(this.transferred / ((now - this.start) / 1000)),\n })\n this.delta = 0\n }\n\n callback(null, chunk)\n }\n\n _flush(callback: any): void {\n if (this.cancellationToken.cancelled) {\n callback(new Error(\"cancelled\"))\n return\n }\n\n this.onProgress({\n total: this.total,\n delta: this.delta,\n transferred: this.total,\n percent: 100,\n bytesPerSecond: Math.round(this.transferred / ((Date.now() - this.start) / 1000)),\n })\n this.delta = 0\n\n callback(null)\n }\n}\n"]}

+391

dist/publishOptions.d.ts

		import { OutgoingHttpHeaders } from "http";
		export type PublishProvider = "github" \| "gitlab" \| "s3" \| "spaces" \| "generic" \| "custom" \| "snapStore" \| "keygen" \| "bitbucket";
		export type AllPublishOptions = string \| GithubOptions \| GitlabOptions \| S3Options \| SpacesOptions \| GenericServerOptions \| CustomPublishOptions \| KeygenOptions \| SnapStoreOptions \| BitbucketOptions;
		export interface PublishConfiguration {
		/**
		* The provider.
		*/
		readonly provider: PublishProvider;
		/**
		* @private
		* win-only
		*/
		publisherName?: Array<string> \| null;
		/**
		* @private
		* win-only
		*/
		readonly updaterCacheDirName?: string \| null;
		/**
		* Whether to publish auto update info files.
		*
		* Auto update relies only on the first provider in the list (you can specify several publishers).
		* Thus, probably, there`s no need to upload the metadata files for the other configured providers. But by default will be uploaded.
		*
		* @default true
		*/
		readonly publishAutoUpdate?: boolean;
		/**
		* Any custom request headers
		*/
		readonly requestHeaders?: OutgoingHttpHeaders;
		/**
		* Request timeout in milliseconds. (Default is 2 minutes; O is ignored)
		*
		* @default 120000
		*/
		readonly timeout?: number \| null;
		}
		export interface CustomPublishOptions extends PublishConfiguration {
		/**
		* The provider. Must be `custom`.
		*/
		readonly provider: "custom";
		/**
		* The Provider to provide UpdateInfo regarding available updates. Required
		* to use custom providers with electron-updater.
		*/
		updateProvider?: new (options: CustomPublishOptions, updater: any, runtimeOptions: any) => any;
		[index: string]: any;
		}
		/**
		* [GitHub](https://help.github.com/articles/about-releases/) options.
		*
		* GitHub [personal access token](https://help.github.com/articles/creating-an-access-token-for-command-line-use/) is required. You can generate by going to [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new). The access token should have the repo scope/permission.
		* Define `GH_TOKEN` environment variable.
		*/
		export interface GithubOptions extends PublishConfiguration {
		/**
		* The provider. Must be `github`.
		*/
		readonly provider: "github";
		/**
		* The repository name. [Detected automatically](#github-repository-and-bintray-package).
		*/
		readonly repo?: string \| null;
		/**
		* The owner.
		*/
		readonly owner?: string \| null;
		/**
		* If defined, sets the prefix of the tag name that comes before the semver number.
		* e.g. "v" in "v1.2.3" or "test" of "test1.2.3".
		* @default "v"
		*/
		readonly tagNamePrefix?: string;
		/**
		* The host (including the port if need).
		* @default github.com
		*/
		readonly host?: string \| null;
		/**
		* The protocol. GitHub Publisher supports only `https`.
		* @default https
		*/
		readonly protocol?: "https" \| "http" \| null;
		/**
		* The access token to support auto-update from private github repositories. Never specify it in the configuration files. Only for [setFeedURL](https://www.electron.build/auto-update#appupdatersetfeedurloptions).
		*/
		readonly token?: string \| null;
		/**
		* Whether to use private github auto-update provider if `GH_TOKEN` environment variable is defined. See [Private GitHub Update Repo](https://www.electron.build/auto-update#private-github-update-repo).
		*/
		readonly private?: boolean \| null;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		/**
		* The type of release. By default `draft` release will be created.
		*
		* Also you can set release type using environment variable. If `EP_DRAFT`is set to `true` — `draft`, if `EP_PRE_RELEASE`is set to `true` — `prerelease`.
		* @default draft
		*/
		releaseType?: "draft" \| "prerelease" \| "release" \| null;
		}
		/** @private */
		export declare function githubUrl(options: GithubOptions, defaultHost?: string): string;
		export declare function githubTagPrefix(options: GithubOptions): string;
		/**
		* [GitLab](https://docs.gitlab.com/ee/user/project/releases/) options.
		*
		* GitLab [personal access token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) is required for private repositories. You can generate one by going to your GitLab profile settings.
		* Define `GITLAB_TOKEN` environment variable.
		*/
		export interface GitlabOptions extends PublishConfiguration {
		/**
		* The provider. Must be `gitlab`.
		*/
		readonly provider: "gitlab";
		/**
		* The GitLab project ID or path (e.g., "12345678" or "namespace/project").
		*/
		readonly projectId?: string \| number \| null;
		/**
		* The GitLab host (including the port if need).
		* @default gitlab.com
		*/
		readonly host?: string \| null;
		/**
		* The access token to support auto-update from private GitLab repositories. Never specify it in the configuration files.
		*/
		readonly token?: string \| null;
		/**
		* Whether to use `v`-prefixed tag name.
		* @default true
		*/
		readonly vPrefixedTagName?: boolean;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		/**
		* Upload target method. Can be "project_upload" for GitLab project uploads or "generic_package" for GitLab generic packages.
		* @default "project_upload"
		*/
		readonly uploadTarget?: "project_upload" \| "generic_package" \| null;
		}
		/**
		* Generic (any HTTP(S) server) options.
		* In all publish options [File Macros](https://www.electron.build/file-patterns#file-macros) are supported.
		*/
		export interface GenericServerOptions extends PublishConfiguration {
		/**
		* The provider. Must be `generic`.
		*/
		readonly provider: "generic";
		/**
		* The base url. e.g. `https://bucket_name.s3.amazonaws.com`.
		*/
		readonly url: string;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		/**
		* Whether to use multiple range requests for differential update. Defaults to `true` if `url` doesn't contain `s3.amazonaws.com`.
		*/
		readonly useMultipleRangeRequest?: boolean;
		}
		/**
		* Keygen options.
		* https://keygen.sh/
		* Define `KEYGEN_TOKEN` environment variable.
		*/
		export interface KeygenOptions extends PublishConfiguration {
		/**
		* The provider. Must be `keygen`.
		*/
		readonly provider: "keygen";
		/**
		* Keygen host for self-hosted instances
		* @default "api.keygen.sh"
		*/
		readonly host?: string;
		/**
		* Keygen account's UUID
		*/
		readonly account: string;
		/**
		* Keygen product's UUID
		*/
		readonly product: string;
		/**
		* The channel.
		* @default stable
		*/
		readonly channel?: "stable" \| "rc" \| "beta" \| "alpha" \| "dev" \| null;
		/**
		* The target Platform. Is set programmatically explicitly during publishing.
		*/
		readonly platform?: string \| null;
		}
		/**
		* Bitbucket options.
		* https://bitbucket.org/
		* Define `BITBUCKET_TOKEN` environment variable.
		*
		* For converting an app password to a usable token, you can utilize this
		```typescript
		convertAppPassword(owner: string, appPassword: string) {
		const base64encodedData = Buffer.from(`${owner}:${appPassword.trim()}`).toString("base64")
		return `Basic ${base64encodedData}`
		}
		```
		*/
		export interface BitbucketOptions extends PublishConfiguration {
		/**
		* The provider. Must be `bitbucket`.
		*/
		readonly provider: "bitbucket";
		/**
		* Repository owner
		*/
		readonly owner: string;
		/**
		* The [app password](https://bitbucket.org/account/settings/app-passwords) to support auto-update from private bitbucket repositories.
		*/
		readonly token?: string \| null;
		/**
		* The user name to support auto-update from private bitbucket repositories.
		*/
		readonly username?: string \| null;
		/**
		* Repository slug/name
		*/
		readonly slug: string;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		}
		/**
		* [Snap Store](https://snapcraft.io/) options. To publish directly to Snapcraft, see <a href="https://snapcraft.io/docs/snapcraft-authentication">Snapcraft authentication options</a> for local or CI/CD authentication options.
		*/
		export interface SnapStoreOptions extends PublishConfiguration {
		/**
		* The provider. Must be `snapStore`.
		*/
		readonly provider: "snapStore";
		/**
		* snapcraft repo name
		*/
		readonly repo?: string;
		/**
		* The list of channels the snap would be released.
		* @default ["edge"]
		*/
		readonly channels?: string \| Array<string> \| null;
		}
		export interface BaseS3Options extends PublishConfiguration {
		/**
		* The update channel.
		* @default latest
		*/
		channel?: string \| null;
		/**
		* The directory path.
		* @default /
		*/
		readonly path?: string \| null;
		/**
		* The ACL. Set to `null` to not [add](https://github.com/electron-userland/electron-builder/issues/1822).
		*
		* @default public-read
		*/
		readonly acl?: "private" \| "public-read" \| null;
		}
		/**
		* [Amazon S3](https://aws.amazon.com/s3/) options.
		* AWS credentials are required, please see [getting your credentials](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/getting-your-credentials.html).
		* To set credentials define `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` [environment variables](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-environment.html) directly,
		* or use [~/.aws/credentials](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-shared.html) file,
		* or use [~/.aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) file. For the last method to work you will also need to define `AWS_SDK_LOAD_CONFIG=1` environment variable.
		*
		* Example configuration:
		*
		```json
		{
		"build":
		"publish": {
		"provider": "s3",
		"bucket": "bucket-name"
		}
		}
		}
		```
		*/
		export interface S3Options extends BaseS3Options {
		/**
		* The provider. Must be `s3`.
		*/
		readonly provider: "s3";
		/**
		* The bucket name.
		*/
		readonly bucket: string;
		/**
		* The region. Is determined and set automatically when publishing.
		*/
		region?: string \| null;
		/**
		* The ACL. Set to `null` to not [add](https://github.com/electron-userland/electron-builder/issues/1822).
		*
		* Please see [required permissions for the S3 provider](https://github.com/electron-userland/electron-builder/issues/1618#issuecomment-314679128).
		*
		* @default public-read
		*/
		readonly acl?: "private" \| "public-read" \| null;
		/**
		* The type of storage to use for the object.
		* @default STANDARD
		*/
		readonly storageClass?: "STANDARD" \| "REDUCED_REDUNDANCY" \| "STANDARD_IA" \| null;
		/**
		* Server-side encryption algorithm to use for the object.
		*/
		readonly encryption?: "AES256" \| "aws:kms" \| null;
		/**
		* The endpoint URI to send requests to. The default endpoint is built from the configured region.
		* The endpoint should be a string like `https://{service}.{region}.amazonaws.com`.
		*/
		readonly endpoint?: string \| null;
		/**
		* If set to true, this will enable the s3 accelerated endpoint
		* These endpoints have a particular format of:
		* ${bucketname}.s3-accelerate.amazonaws.com
		*/
		readonly accelerate?: boolean;
		/**
		* When true, force a path-style endpoint to be used where the bucket name is part of the path.
		* [Path-style Access](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access)
		*/
		readonly forcePathStyle?: boolean;
		}
		/**
		* [DigitalOcean Spaces](https://www.digitalocean.com/community/tutorials/an-introduction-to-digitalocean-spaces) options.
		* Access key is required, define `DO_KEY_ID` and `DO_SECRET_KEY` environment variables.
		*/
		export interface SpacesOptions extends BaseS3Options {
		/**
		* The provider. Must be `spaces`.
		*/
		readonly provider: "spaces";
		/**
		* The space name.
		*/
		readonly name: string;
		/**
		* The region (e.g. `nyc3`).
		*/
		readonly region: string;
		}
		export interface GitlabReleaseInfo {
		name: string;
		tag_name: string;
		description: string;
		created_at: string;
		released_at: string;
		upcoming_release: boolean;
		assets: GitlabReleaseAsset;
		}
		export interface GitlabReleaseAsset {
		count: number;
		sources: Array<{
		format: string;
		url: string;
		}>;
		links: Array<{
		id: number;
		name: string;
		url: string;
		direct_asset_url: string;
		link_type: string;
		}>;
		}
		export declare function getS3LikeProviderBaseUrl(configuration: PublishConfiguration): string;
		//# sourceMappingURL=publishOptions.d.ts.map

+1

dist/publishOptions.d.ts.map

+64

dist/publishOptions.js

		/** @private */
		export function githubUrl(options, defaultHost = "github.com") {
		return `${options.protocol \|\| "https"}://${options.host \|\| defaultHost}`;
		}
		export function githubTagPrefix(options) {
		return options.tagNamePrefix ?? "v";
		}
		export function getS3LikeProviderBaseUrl(configuration) {
		const provider = configuration.provider;
		if (provider === "s3") {
		return s3Url(configuration);
		}
		if (provider === "spaces") {
		return spacesUrl(configuration);
		}
		throw new Error(`Not supported provider: ${provider}`);
		}
		function s3Url(options) {
		let url;
		if (options.accelerate == true) {
		url = `https://${options.bucket}.s3-accelerate.amazonaws.com`;
		}
		else if (options.endpoint != null) {
		url = `${options.endpoint}/${options.bucket}`;
		}
		else if (options.bucket.includes(".")) {
		if (options.region == null) {
		throw new Error(`Bucket name "${options.bucket}" includes a dot, but S3 region is missing`);
		}
		// special case, see http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro
		if (options.region === "us-east-1") {
		url = `https://s3.amazonaws.com/${options.bucket}`;
		}
		else {
		url = `https://s3-${options.region}.amazonaws.com/${options.bucket}`;
		}
		}
		else if (options.region === "cn-north-1") {
		url = `https://${options.bucket}.s3.${options.region}.amazonaws.com.cn`;
		}
		else {
		url = `https://${options.bucket}.s3.amazonaws.com`;
		}
		return appendPath(url, options.path);
		}
		function appendPath(url, p) {
		if (p != null && p.length > 0) {
		if (!p.startsWith("/")) {
		url += "/";
		}
		url += p;
		}
		return url;
		}
		function spacesUrl(options) {
		if (options.name == null) {
		throw new Error(`name is missing`);
		}
		if (options.region == null) {
		throw new Error(`region is missing`);
		}
		return appendPath(`https://${options.name}.${options.region}.digitaloceanspaces.com`, options.path);
		}
		//# sourceMappingURL=publishOptions.js.map

+1

dist/publishOptions.js.map

+12

dist/retry.d.ts

		import { setTimeout as sleep } from "timers/promises";
		export { sleep };
		import { CancellationToken } from "./CancellationToken.js";
		export declare function retry<T>(task: () => Promise<T>, options: {
		retries: number;
		interval: number;
		backoff?: number;
		attempt?: number;
		cancellationToken?: CancellationToken;
		shouldRetry?: (e: any) => boolean \| Promise<boolean>;
		}): Promise<T>;
		//# sourceMappingURL=retry.d.ts.map

+1

dist/retry.d.ts.map

{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAE,KAAK,EAAE,CAAA;AAEhB,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE1D,wBAAsB,KAAK,CAAC,CAAC,EAC3B,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAAC,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,GAC9K,OAAO,CAAC,CAAC,CAAC,CAYZ"}

+19

dist/retry.js

		import { setTimeout as sleep } from "timers/promises";
		export { sleep };
		import { CancellationToken } from "./CancellationToken.js";
		export async function retry(task, options) {
		const { retries: retryCount, interval, backoff = 0, attempt = 0, shouldRetry, cancellationToken = new CancellationToken() } = options;
		try {
		return await task();
		}
		catch (error) {
		if ((await Promise.resolve(shouldRetry?.(error) ?? true)) && retryCount > 0 && !cancellationToken.cancelled) {
		await sleep(interval + backoff * attempt);
		return await retry(task, { ...options, retries: retryCount - 1, attempt: attempt + 1 });
		}
		else {
		throw error;
		}
		}
		}
		//# sourceMappingURL=retry.js.map

+1

dist/retry.js.map

{"version":3,"file":"retry.js","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAE,KAAK,EAAE,CAAA;AAEhB,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE1D,MAAM,CAAC,KAAK,UAAU,KAAK,CACzB,IAAsB,EACtB,OAA+K;IAE/K,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,WAAW,EAAE,iBAAiB,GAAG,IAAI,iBAAiB,EAAE,EAAE,GAAG,OAAO,CAAA;IACrI,IAAI,CAAC;QACH,OAAO,MAAM,IAAI,EAAE,CAAA;IACrB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,IAAI,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,UAAU,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YAC5G,MAAM,KAAK,CAAC,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC,CAAA;YACzC,OAAO,MAAM,KAAK,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAA;QACzF,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import { setTimeout as sleep } from \"timers/promises\"\nexport { sleep }\n\nimport { CancellationToken } from \"./CancellationToken.js\"\n\nexport async function retry<T>(\n task: () => Promise<T>,\n options: { retries: number; interval: number; backoff?: number; attempt?: number; cancellationToken?: CancellationToken; shouldRetry?: (e: any) => boolean | Promise<boolean> }\n): Promise<T> {\n const { retries: retryCount, interval, backoff = 0, attempt = 0, shouldRetry, cancellationToken = new CancellationToken() } = options\n try {\n return await task()\n } catch (error: any) {\n if ((await Promise.resolve(shouldRetry?.(error) ?? true)) && retryCount > 0 && !cancellationToken.cancelled) {\n await sleep(interval + backoff * attempt)\n return await retry(task, { ...options, retries: retryCount - 1, attempt: attempt + 1 })\n } else {\n throw error\n }\n }\n}\n"]}

+2

dist/rfc2253Parser.d.ts

		export declare function parseDn(seq: string): Map<string, string>;
		//# sourceMappingURL=rfc2253Parser.d.ts.map

+1

dist/rfc2253Parser.d.ts.map

{"version":3,"file":"rfc2253Parser.d.ts","sourceRoot":"","sources":["../src/rfc2253Parser.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqFxD"}

+77

dist/rfc2253Parser.js

		export function parseDn(seq) {
		let quoted = false;
		let key = null;
		let token = "";
		let nextNonSpace = 0;
		seq = seq.trim();
		const result = new Map();
		for (let i = 0; i <= seq.length; i++) {
		if (i === seq.length) {
		if (key !== null) {
		result.set(key, token);
		}
		break;
		}
		const ch = seq[i];
		if (quoted) {
		if (ch === '"') {
		quoted = false;
		continue;
		}
		}
		else {
		if (ch === '"') {
		quoted = true;
		continue;
		}
		if (ch === "\\") {
		i++;
		const ord = parseInt(seq.slice(i, i + 2), 16);
		if (Number.isNaN(ord)) {
		token += seq[i];
		}
		else {
		i++;
		token += String.fromCharCode(ord);
		}
		continue;
		}
		if (key === null && ch === "=") {
		key = token;
		token = "";
		continue;
		}
		if (ch === "," \|\| ch === ";" \|\| ch === "+") {
		if (key !== null) {
		result.set(key, token);
		}
		key = null;
		token = "";
		continue;
		}
		}
		if (ch === " " && !quoted) {
		if (token.length === 0) {
		continue;
		}
		if (i > nextNonSpace) {
		let j = i;
		while (seq[j] === " ") {
		j++;
		}
		nextNonSpace = j;
		}
		if (nextNonSpace >= seq.length \|\|
		seq[nextNonSpace] === "," \|\|
		seq[nextNonSpace] === ";" \|\|
		(key === null && seq[nextNonSpace] === "=") \|\|
		(key !== null && seq[nextNonSpace] === "+")) {
		i = nextNonSpace - 1;
		continue;
		}
		}
		token += ch;
		}
		return result;
		}
		//# sourceMappingURL=rfc2253Parser.js.map

+1

dist/rfc2253Parser.js.map

{"version":3,"file":"rfc2253Parser.js","sourceRoot":"","sources":["../src/rfc2253Parser.ts"],"names":[],"mappings":"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","sourcesContent":["export function parseDn(seq: string): Map<string, string> {\n let quoted = false\n let key: string | null = null\n let token = \"\"\n let nextNonSpace = 0\n\n seq = seq.trim()\n const result = new Map<string, string>()\n for (let i = 0; i <= seq.length; i++) {\n if (i === seq.length) {\n if (key !== null) {\n result.set(key, token)\n }\n break\n }\n\n const ch = seq[i]\n if (quoted) {\n if (ch === '\"') {\n quoted = false\n continue\n }\n } else {\n if (ch === '\"') {\n quoted = true\n continue\n }\n\n if (ch === \"\\\\\") {\n i++\n const ord = parseInt(seq.slice(i, i + 2), 16)\n if (Number.isNaN(ord)) {\n token += seq[i]\n } else {\n i++\n token += String.fromCharCode(ord)\n }\n continue\n }\n\n if (key === null && ch === \"=\") {\n key = token\n token = \"\"\n continue\n }\n\n if (ch === \",\" || ch === \";\" || ch === \"+\") {\n if (key !== null) {\n result.set(key, token)\n }\n key = null\n token = \"\"\n continue\n }\n }\n\n if (ch === \" \" && !quoted) {\n if (token.length === 0) {\n continue\n }\n\n if (i > nextNonSpace) {\n let j = i\n while (seq[j] === \" \") {\n j++\n }\n nextNonSpace = j\n }\n\n if (\n nextNonSpace >= seq.length ||\n seq[nextNonSpace] === \",\" ||\n seq[nextNonSpace] === \";\" ||\n (key === null && seq[nextNonSpace] === \"=\") ||\n (key !== null && seq[nextNonSpace] === \"+\")\n ) {\n i = nextNonSpace - 1\n continue\n }\n }\n\n token += ch\n }\n\n return result\n}\n"]}

+77

dist/updateInfo.d.ts

		export interface ReleaseNoteInfo {
		/**
		* The version.
		*/
		readonly version: string;
		/**
		* The note.
		*/
		readonly note: string \| null;
		}
		export interface BlockMapDataHolder {
		/**
		* The file size. Used to verify downloaded size (save one HTTP request to get length).
		* Also used when block map data is embedded into the file (appimage, windows web installer package).
		*/
		size?: number;
		/**
		* The block map file size. Used when block map data is embedded into the file (appimage, windows web installer package).
		* This information can be obtained from the file itself, but it requires additional HTTP request,
		* so, to reduce request count, block map size is specified in the update metadata too.
		*/
		blockMapSize?: number;
		/**
		* The file checksum.
		*/
		readonly sha512: string;
		readonly isAdminRightsRequired?: boolean;
		}
		export interface PackageFileInfo extends BlockMapDataHolder {
		readonly path: string;
		}
		export interface UpdateFileInfo extends BlockMapDataHolder {
		url: string;
		}
		export interface UpdateInfo {
		/**
		* The version.
		*/
		readonly version: string;
		readonly files: Array<UpdateFileInfo>;
		/** @deprecated */
		readonly path: string;
		/** @deprecated */
		readonly sha512: string;
		/**
		* The release name.
		*/
		releaseName?: string \| null;
		/**
		* The release notes. List if `updater.fullChangelog` is set to `true`, `string` otherwise.
		*/
		releaseNotes?: string \| Array<ReleaseNoteInfo> \| null;
		/**
		* The release date.
		*/
		releaseDate: string;
		/**
		* The [staged rollout](https://www.electron.build/auto-update#staged-rollouts) percentage, 0-100.
		*/
		readonly stagingPercentage?: number;
		/**
		* The minimum version of system required for the app to run. Sample value: macOS `23.1.0`, Windows `10.0.22631`.
		* Same with os.release() value, this is a kernel version.
		*/
		readonly minimumSystemVersion?: string;
		}
		export interface WindowsUpdateInfo extends UpdateInfo {
		packages?: {
		[arch: string]: PackageFileInfo;
		} \| null;
		/**
		* @deprecated
		* @private
		*/
		sha2?: string;
		}
		//# sourceMappingURL=updateInfo.d.ts.map

+1

dist/updateInfo.d.ts.map

{"version":3,"file":"updateInfo.d.ts","sourceRoot":"","sources":["../src/updateInfo.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAA;CACzC;AAED,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,cAAe,SAAQ,kBAAkB;IACxD,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,CAAA;IAErC,kBAAkB;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB,kBAAkB;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAE3B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,CAAC,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAEnC;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CACvC;AAED,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,QAAQ,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE,GAAG,IAAI,CAAA;IAErD;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;CACd"}

+2

dist/updateInfo.js

		export {};
		//# sourceMappingURL=updateInfo.js.map

+1

dist/updateInfo.js.map

{"version":3,"file":"updateInfo.js","sourceRoot":"","sources":["../src/updateInfo.ts"],"names":[],"mappings":"","sourcesContent":["export interface ReleaseNoteInfo {\n /**\n * The version.\n */\n readonly version: string\n\n /**\n * The note.\n */\n readonly note: string | null\n}\n\nexport interface BlockMapDataHolder {\n /**\n * The file size. Used to verify downloaded size (save one HTTP request to get length).\n * Also used when block map data is embedded into the file (appimage, windows web installer package).\n */\n size?: number\n\n /**\n * The block map file size. Used when block map data is embedded into the file (appimage, windows web installer package).\n * This information can be obtained from the file itself, but it requires additional HTTP request,\n * so, to reduce request count, block map size is specified in the update metadata too.\n */\n blockMapSize?: number\n\n /**\n * The file checksum.\n */\n readonly sha512: string\n\n readonly isAdminRightsRequired?: boolean\n}\n\nexport interface PackageFileInfo extends BlockMapDataHolder {\n readonly path: string\n}\n\nexport interface UpdateFileInfo extends BlockMapDataHolder {\n url: string\n}\n\nexport interface UpdateInfo {\n /**\n * The version.\n */\n readonly version: string\n\n readonly files: Array<UpdateFileInfo>\n\n /** @deprecated */\n readonly path: string\n\n /** @deprecated */\n readonly sha512: string\n\n /**\n * The release name.\n */\n releaseName?: string | null\n\n /**\n * The release notes. List if `updater.fullChangelog` is set to `true`, `string` otherwise.\n */\n releaseNotes?: string | Array<ReleaseNoteInfo> | null\n\n /**\n * The release date.\n */\n releaseDate: string\n\n /**\n * The [staged rollout](https://www.electron.build/auto-update#staged-rollouts) percentage, 0-100.\n */\n readonly stagingPercentage?: number\n\n /**\n * The minimum version of system required for the app to run. Sample value: macOS `23.1.0`, Windows `10.0.22631`.\n * Same with os.release() value, this is a kernel version.\n */\n readonly minimumSystemVersion?: string\n}\n\nexport interface WindowsUpdateInfo extends UpdateInfo {\n packages?: { [arch: string]: PackageFileInfo } | null\n\n /**\n * @deprecated\n * @private\n */\n sha2?: string\n}\n"]}

+22

dist/uuid.d.ts

		export declare class UUID {
		private ascii;
		private readonly binary;
		private readonly version;
		static readonly OID: Buffer;
		constructor(uuid: Buffer \| string);
		static v5(name: string \| Buffer, namespace: Buffer): any;
		toString(): string;
		inspect(): string;
		static check(uuid: Buffer \| string, offset?: number): false \| {
		version: undefined;
		variant: string;
		format: string;
		} \| {
		version: number;
		variant: string;
		format: string;
		};
		static parse(input: string): Buffer;
		}
		export declare const nil: UUID;
		//# sourceMappingURL=uuid.d.ts.map

+1

dist/uuid.d.ts.map

{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"AAsBA,qBAAa,IAAI;IACf,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAGhC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAqD;gBAEpE,IAAI,EAAE,MAAM,GAAG,MAAM;IAejC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM;IAIlD,QAAQ;IAOR,OAAO;IAIP,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,SAAI;;;;;;;;;IA6C9C,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAWpC;AAuGD,eAAO,MAAM,GAAG,MAAmD,CAAA"}

+196

dist/uuid.js

		import { createHash, randomBytes } from "crypto";
		import { newError } from "./error.js";
		const invalidName = "options.name must be either a string or a Buffer";
		// Node ID according to rfc4122#section-4.5
		const randomHost = randomBytes(16);
		randomHost[0] = randomHost[0] \| 0x01;
		// lookup table hex to byte
		const hex2byte = {};
		// lookup table byte to hex
		const byte2hex = [];
		// populate lookup tables
		for (let i = 0; i < 256; i++) {
		const hex = (i + 0x100).toString(16).substr(1);
		hex2byte[hex] = i;
		byte2hex[i] = hex;
		}
		// UUID class
		export class UUID {
		// from rfc4122#appendix-C
		static { this.OID = UUID.parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"); }
		constructor(uuid) {
		this.ascii = null;
		this.binary = null;
		const check = UUID.check(uuid);
		if (!check) {
		throw new Error("not a UUID");
		}
		this.version = check.version;
		if (check.format === "ascii") {
		this.ascii = uuid;
		}
		else {
		this.binary = uuid;
		}
		}
		static v5(name, namespace) {
		return uuidNamed(name, "sha1", 0x50, namespace);
		}
		toString() {
		if (this.ascii == null) {
		this.ascii = stringify(this.binary);
		}
		return this.ascii;
		}
		inspect() {
		return `UUID v${this.version} ${this.toString()}`;
		}
		static check(uuid, offset = 0) {
		if (typeof uuid === "string") {
		uuid = uuid.toLowerCase();
		if (!/^[a-f0-9]{8}(-[a-f0-9]{4}){3}-([a-f0-9]{12})$/.test(uuid)) {
		return false;
		}
		if (uuid === "00000000-0000-0000-0000-000000000000") {
		return { version: undefined, variant: "nil", format: "ascii" };
		}
		return {
		version: (hex2byte[uuid[14] + uuid[15]] & 0xf0) >> 4,
		variant: getVariant((hex2byte[uuid[19] + uuid[20]] & 0xe0) >> 5),
		format: "ascii",
		};
		}
		if (Buffer.isBuffer(uuid)) {
		if (uuid.length < offset + 16) {
		return false;
		}
		let i = 0;
		for (; i < 16; i++) {
		if (uuid[offset + i] !== 0) {
		break;
		}
		}
		if (i === 16) {
		return { version: undefined, variant: "nil", format: "binary" };
		}
		return {
		version: (uuid[offset + 6] & 0xf0) >> 4,
		variant: getVariant((uuid[offset + 8] & 0xe0) >> 5),
		format: "binary",
		};
		}
		throw newError("Unknown type of uuid", "ERR_UNKNOWN_UUID_TYPE");
		}
		// read stringified uuid into a Buffer
		static parse(input) {
		const buffer = Buffer.allocUnsafe(16);
		let j = 0;
		for (let i = 0; i < 16; i++) {
		buffer[i] = hex2byte[input[j++] + input[j++]];
		if (i === 3 \|\| i === 5 \|\| i === 7 \|\| i === 9) {
		j += 1;
		}
		}
		return buffer;
		}
		}
		// according to rfc4122#section-4.1.1
		function getVariant(bits) {
		switch (bits) {
		case 0:
		case 1:
		case 3:
		return "ncs";
		case 4:
		case 5:
		return "rfc4122";
		case 6:
		return "microsoft";
		default:
		return "future";
		}
		}
		var UuidEncoding;
		(function (UuidEncoding) {
		UuidEncoding[UuidEncoding["ASCII"] = 0] = "ASCII";
		UuidEncoding[UuidEncoding["BINARY"] = 1] = "BINARY";
		UuidEncoding[UuidEncoding["OBJECT"] = 2] = "OBJECT";
		})(UuidEncoding \|\| (UuidEncoding = {}));
		// v3 + v5
		function uuidNamed(name, hashMethod, version, namespace, encoding = UuidEncoding.ASCII) {
		const hash = createHash(hashMethod);
		const nameIsNotAString = typeof name !== "string";
		if (nameIsNotAString && !Buffer.isBuffer(name)) {
		throw newError(invalidName, "ERR_INVALID_UUID_NAME");
		}
		hash.update(namespace);
		hash.update(name);
		const buffer = hash.digest();
		let result;
		switch (encoding) {
		case UuidEncoding.BINARY:
		buffer[6] = (buffer[6] & 0x0f) \| version;
		buffer[8] = (buffer[8] & 0x3f) \| 0x80;
		result = buffer;
		break;
		case UuidEncoding.OBJECT:
		buffer[6] = (buffer[6] & 0x0f) \| version;
		buffer[8] = (buffer[8] & 0x3f) \| 0x80;
		result = new UUID(buffer);
		break;
		default:
		result =
		byte2hex[buffer[0]] +
		byte2hex[buffer[1]] +
		byte2hex[buffer[2]] +
		byte2hex[buffer[3]] +
		"-" +
		byte2hex[buffer[4]] +
		byte2hex[buffer[5]] +
		"-" +
		byte2hex[(buffer[6] & 0x0f) \| version] +
		byte2hex[buffer[7]] +
		"-" +
		byte2hex[(buffer[8] & 0x3f) \| 0x80] +
		byte2hex[buffer[9]] +
		"-" +
		byte2hex[buffer[10]] +
		byte2hex[buffer[11]] +
		byte2hex[buffer[12]] +
		byte2hex[buffer[13]] +
		byte2hex[buffer[14]] +
		byte2hex[buffer[15]];
		break;
		}
		return result;
		}
		function stringify(buffer) {
		return (byte2hex[buffer[0]] +
		byte2hex[buffer[1]] +
		byte2hex[buffer[2]] +
		byte2hex[buffer[3]] +
		"-" +
		byte2hex[buffer[4]] +
		byte2hex[buffer[5]] +
		"-" +
		byte2hex[buffer[6]] +
		byte2hex[buffer[7]] +
		"-" +
		byte2hex[buffer[8]] +
		byte2hex[buffer[9]] +
		"-" +
		byte2hex[buffer[10]] +
		byte2hex[buffer[11]] +
		byte2hex[buffer[12]] +
		byte2hex[buffer[13]] +
		byte2hex[buffer[14]] +
		byte2hex[buffer[15]]);
		}
		// according to rfc4122#section-4.1.7
		export const nil = new UUID("00000000-0000-0000-0000-000000000000");
		// UUID.v4 = uuidRandom
		// UUID.v4fast = uuidRandomFast
		// UUID.v3 = function(options, callback) {
		// return uuidNamed("md5", 0x30, options, callback)
		// }
		//# sourceMappingURL=uuid.js.map

+1

dist/uuid.js.map

+16

dist/xml.d.ts

		export declare class XElement {
		readonly name: string;
		value: string;
		attributes: Record<string, string> \| null;
		isCData: boolean;
		elements: Array<XElement> \| null;
		constructor(name: string);
		attribute(name: string): string;
		removeAttribute(name: string): void;
		element(name: string, ignoreCase?: boolean, errorIfMissed?: string \| null): XElement;
		elementOrNull(name: string, ignoreCase?: boolean): XElement \| null;
		getElements(name: string, ignoreCase?: boolean): XElement[];
		elementValueOrEmpty(name: string, ignoreCase?: boolean): string;
		}
		export declare function parseXml(data: string): XElement;
		//# sourceMappingURL=xml.d.ts.map

+1

dist/xml.d.ts.map

{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../src/xml.ts"],"names":[],"mappings":"AAGA,qBAAa,QAAQ;IAMP,QAAQ,CAAC,IAAI,EAAE,MAAM;IALjC,KAAK,SAAK;IACV,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAO;IAChD,OAAO,UAAQ;IACf,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAO;gBAElB,IAAI,EAAE,MAAM;IASjC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQ/B,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAMnC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ,EAAE,aAAa,GAAE,MAAM,GAAG,IAAW,GAAG,QAAQ;IAQxF,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,QAAQ,GAAG,IAAI;IAchE,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ;IAO5C,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,MAAM;CAI9D;AAaD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CA2C/C"}

+104

dist/xml.js

		import * as sax from "sax";
		import { newError } from "./error.js";
		export class XElement {
		constructor(name) {
		this.name = name;
		this.value = "";
		this.attributes = null;
		this.isCData = false;
		this.elements = null;
		if (!name) {
		throw newError("Element name cannot be empty", "ERR_XML_ELEMENT_NAME_EMPTY");
		}
		if (!isValidName(name)) {
		throw newError(`Invalid element name: ${name}`, "ERR_XML_ELEMENT_INVALID_NAME");
		}
		}
		attribute(name) {
		const result = this.attributes === null ? null : this.attributes[name];
		if (result == null) {
		throw newError(`No attribute "${name}"`, "ERR_XML_MISSED_ATTRIBUTE");
		}
		return result;
		}
		removeAttribute(name) {
		if (this.attributes !== null) {
		delete this.attributes[name];
		}
		}
		element(name, ignoreCase = false, errorIfMissed = null) {
		const result = this.elementOrNull(name, ignoreCase);
		if (result === null) {
		throw newError(errorIfMissed \|\| `No element "${name}"`, "ERR_XML_MISSED_ELEMENT");
		}
		return result;
		}
		elementOrNull(name, ignoreCase = false) {
		if (this.elements === null) {
		return null;
		}
		for (const element of this.elements) {
		if (isNameEquals(element, name, ignoreCase)) {
		return element;
		}
		}
		return null;
		}
		getElements(name, ignoreCase = false) {
		if (this.elements === null) {
		return [];
		}
		return this.elements.filter(it => isNameEquals(it, name, ignoreCase));
		}
		elementValueOrEmpty(name, ignoreCase = false) {
		const element = this.elementOrNull(name, ignoreCase);
		return element === null ? "" : element.value;
		}
		}
		const NAME_REG_EXP = new RegExp(/^[A-Za-z_][:A-Za-z0-9_-]*$/i);
		function isValidName(name) {
		return NAME_REG_EXP.test(name);
		}
		function isNameEquals(element, name, ignoreCase) {
		const elementName = element.name;
		return elementName === name \|\| (ignoreCase === true && elementName.length === name.length && elementName.toLowerCase() === name.toLowerCase());
		}
		export function parseXml(data) {
		let rootElement = null;
		const parser = sax.parser(true, {});
		const elements = [];
		parser.onopentag = saxElement => {
		const element = new XElement(saxElement.name);
		element.attributes = saxElement.attributes;
		if (rootElement === null) {
		rootElement = element;
		}
		else {
		const parent = elements[elements.length - 1];
		if (parent.elements == null) {
		parent.elements = [];
		}
		parent.elements.push(element);
		}
		elements.push(element);
		};
		parser.onclosetag = () => {
		elements.pop();
		};
		parser.ontext = text => {
		if (elements.length > 0) {
		elements[elements.length - 1].value = text;
		}
		};
		parser.oncdata = cdata => {
		const element = elements[elements.length - 1];
		element.value = cdata;
		element.isCData = true;
		};
		parser.onerror = err => {
		throw err;
		};
		parser.write(data);
		return rootElement;
		}
		//# sourceMappingURL=xml.js.map

+1

dist/xml.js.map

+22

-5

package.json

		{
		"name": "builder-util-runtime",
		"version": "9.7.0",
		"main": "out/index.js",
		"version": "10.0.0-alpha.0",
		"type": "module",
		"main": "./dist/index.js",
		"exports": {
		".": {
		"types": "./dist/index.d.ts",
		"import": "./dist/index.js",
		"require": "./dist/index.js"
		},
		"./internal": {
		"types": "./dist/indexInternal.d.ts",
		"import": "./dist/indexInternal.js",
		"require": "./dist/indexInternal.js"
		}
		},
		"author": "Vladimir Krivosheev",
		@@ -15,6 +28,6 @@ "license": "MIT",
		"files": [
		"out"
		"dist"
		],
		"engines": {
		"node": ">=12.0.0"
		"node": ">=22.12.0"
		},
		@@ -29,3 +42,7 @@ "dependencies": {
		},
		"types": "./out/index.d.ts"
		"types": "./dist/index.d.ts",
		"scripts": {
		"build": "tsc --build tsconfig.build.json --force",
		"watch": "tsc --build tsconfig.build.json --watch"
		}
		}

-12

out/blockMapApi.d.ts

		export interface FileChunks {
		checksums: Array<string>;
		sizes: Array<number>;
		}
		export interface BlockMap {
		version: "1" \| "2";
		files: Array<BlockMapFile>;
		}
		export interface BlockMapFile extends FileChunks {
		name: string;
		offset: number;
		}

-3

out/blockMapApi.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		//# sourceMappingURL=blockMapApi.js.map

-1

out/blockMapApi.js.map

{"version":3,"file":"blockMapApi.js","sourceRoot":"","sources":["../src/blockMapApi.ts"],"names":[],"mappings":"","sourcesContent":["export interface FileChunks {\n checksums: Array<string>\n sizes: Array<number>\n}\n\nexport interface BlockMap {\n version: \"1\" | \"2\"\n files: Array<BlockMapFile>\n}\n\nexport interface BlockMapFile extends FileChunks {\n name: string\n offset: number\n}\n"]}

-17

out/CancellationToken.d.ts

		import { EventEmitter } from "events";
		export declare class CancellationToken extends EventEmitter {
		private parentCancelHandler;
		private _cancelled;
		get cancelled(): boolean;
		private _parent;
		set parent(value: CancellationToken);
		constructor(parent?: CancellationToken);
		cancel(): void;
		private onCancel;
		createPromise<R>(callback: (resolve: (thenableOrResult: R \| PromiseLike<R>) => void, reject: (error: Error) => void, onCancel: (callback: () => void) => void) => void): Promise<R>;
		private removeParentCancelHandler;
		dispose(): void;
		}
		export declare class CancellationError extends Error {
		constructor();
		}

-108

out/CancellationToken.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.CancellationError = exports.CancellationToken = void 0;
		const events_1 = require("events");
		class CancellationToken extends events_1.EventEmitter {
		get cancelled() {
		return this._cancelled \|\| (this._parent != null && this._parent.cancelled);
		}
		set parent(value) {
		this.removeParentCancelHandler();
		this._parent = value;
		this.parentCancelHandler = () => this.cancel();
		this._parent.onCancel(this.parentCancelHandler);
		}
		// babel cannot compile ... correctly for super calls
		constructor(parent) {
		super();
		this.parentCancelHandler = null;
		this._parent = null;
		this._cancelled = false;
		if (parent != null) {
		this.parent = parent;
		}
		}
		cancel() {
		this._cancelled = true;
		this.emit("cancel");
		}
		onCancel(handler) {
		if (this.cancelled) {
		handler();
		}
		else {
		this.once("cancel", handler);
		}
		}
		createPromise(callback) {
		if (this.cancelled) {
		return Promise.reject(new CancellationError());
		}
		const finallyHandler = () => {
		if (cancelHandler != null) {
		try {
		this.removeListener("cancel", cancelHandler);
		cancelHandler = null;
		}
		catch (_ignore) {
		// ignore
		}
		}
		};
		let cancelHandler = null;
		return new Promise((resolve, reject) => {
		let addedCancelHandler = null;
		cancelHandler = () => {
		try {
		if (addedCancelHandler != null) {
		addedCancelHandler();
		addedCancelHandler = null;
		}
		}
		finally {
		reject(new CancellationError());
		}
		};
		if (this.cancelled) {
		cancelHandler();
		return;
		}
		this.onCancel(cancelHandler);
		callback(resolve, reject, (callback) => {
		addedCancelHandler = callback;
		});
		})
		.then(it => {
		finallyHandler();
		return it;
		})
		.catch((e) => {
		finallyHandler();
		throw e;
		});
		}
		removeParentCancelHandler() {
		const parent = this._parent;
		if (parent != null && this.parentCancelHandler != null) {
		parent.removeListener("cancel", this.parentCancelHandler);
		this.parentCancelHandler = null;
		}
		}
		dispose() {
		try {
		this.removeParentCancelHandler();
		}
		finally {
		this.removeAllListeners();
		this._parent = null;
		}
		}
		}
		exports.CancellationToken = CancellationToken;
		class CancellationError extends Error {
		constructor() {
		super("cancelled");
		}
		}
		exports.CancellationError = CancellationError;
		//# sourceMappingURL=CancellationToken.js.map

-1

out/CancellationToken.js.map

-1

out/error.d.ts

export declare function newError(message: string, code: string): Error;

-9

out/error.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.newError = newError;
		function newError(message, code) {
		const error = new Error(message);
		error.code = code;
		return error;
		}
		//# sourceMappingURL=error.js.map

-1

out/error.js.map

{"version":3,"file":"error.js","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":";;AAAA,4BAIC;AAJD,SAAgB,QAAQ,CAAC,OAAe,EAAE,IAAY;IACpD,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAC/B;IAAC,KAA+B,CAAC,IAAI,GAAG,IAAI,CAAA;IAC7C,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["export function newError(message: string, code: string) {\n const error = new Error(message)\n ;(error as NodeJS.ErrnoException).code = code\n return error\n}\n"]}

-86

out/httpExecutor.d.ts

		import { BinaryToTextEncoding } from "crypto";
		import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, RequestOptions } from "http";
		import { Transform } from "stream";
		import { URL } from "url";
		import { CancellationToken } from "./CancellationToken";
		import { ProgressInfo } from "./ProgressCallbackTransform";
		/**
		* Register an additional HTTP header to strip on cross-origin redirects.
		* Intended for custom publishers (e.g. GenericPublisher with a non-standard auth header).
		*/
		export declare function addSensitiveRedirectHeader(header: string): void;
		/**
		* Register an additional substring pattern used by {@link safeStringifyJson} to
		* identify sensitive field names. Input is normalized (lowercased, separators stripped).
		* Intended for custom publishers that store credentials under non-standard field names.
		*/
		export declare function addSensitiveFieldPattern(pattern: string): void;
		export interface RequestHeaders extends OutgoingHttpHeaders {
		[key: string]: OutgoingHttpHeader \| undefined;
		}
		export interface DownloadOptions {
		readonly headers?: OutgoingHttpHeaders \| null;
		readonly sha2?: string \| null;
		readonly sha512?: string \| null;
		readonly cancellationToken: CancellationToken;
		onProgress?: (progress: ProgressInfo) => void;
		}
		export declare function createHttpError(response: IncomingMessage, description?: any \| null): HttpError;
		export declare class HttpError extends Error {
		readonly statusCode: number;
		readonly description: any \| null;
		constructor(statusCode: number, message?: string, description?: any \| null);
		isServerError(): boolean;
		}
		export declare function parseJson(result: Promise<string \| null>): Promise<any>;
		interface Request {
		abort: () => void;
		end: (data?: Buffer) => void;
		}
		export declare abstract class HttpExecutor<T extends Request> {
		protected readonly maxRedirects = 10;
		request(options: RequestOptions, cancellationToken?: CancellationToken, data?: {
		[name: string]: any;
		} \| null): Promise<string \| null>;
		doApiRequest(options: RequestOptions, cancellationToken: CancellationToken, requestProcessor: (request: T, reject: (error: Error) => void) => void, redirectCount?: number): Promise<string>;
		protected addRedirectHandlers(request: any, options: RequestOptions, reject: (error: Error) => void, redirectCount: number, handler: (options: RequestOptions) => void): void;
		addErrorAndTimeoutHandlers(request: any, reject: (error: Error) => void, timeout?: number): void;
		private handleResponse;
		abstract createRequest(options: RequestOptions, callback: (response: any) => void): T;
		downloadToBuffer(url: URL, options: DownloadOptions): Promise<Buffer>;
		protected doDownload(requestOptions: RequestOptions, options: DownloadCallOptions, redirectCount: number): void;
		protected createMaxRedirectError(): Error;
		private addTimeOutHandler;
		static prepareRedirectUrlOptions(redirectUrl: string, options: RequestOptions): RequestOptions;
		private static reconstructOriginalUrl;
		private static isCrossOriginRedirect;
		static retryOnServerError(task: () => Promise<any>, maxRetries?: number): Promise<any>;
		}
		export interface DownloadCallOptions {
		responseHandler: ((response: IncomingMessage, callback: (error: Error \| null) => void) => void) \| null;
		onCancel: (callback: () => void) => void;
		callback: (error: Error \| null) => void;
		options: DownloadOptions;
		destination: string \| null;
		}
		export declare function configureRequestOptionsFromUrl(url: string, options: RequestOptions): RequestOptions;
		export declare function configureRequestUrl(url: URL, options: RequestOptions): void;
		export declare class DigestTransform extends Transform {
		readonly expected: string;
		private readonly algorithm;
		private readonly encoding;
		private readonly digester;
		private _actual;
		get actual(): string \| null;
		isValidateOnEnd: boolean;
		constructor(expected: string, algorithm?: string, encoding?: BinaryToTextEncoding);
		_transform(chunk: Buffer, encoding: string, callback: any): void;
		_flush(callback: any): void;
		validate(): null;
		}
		export declare function safeGetHeader(response: any, headerKey: string): any;
		export declare function configureRequestOptions(options: RequestOptions, token?: string \| null, method?: "GET" \| "DELETE" \| "PUT" \| "POST"): RequestOptions;
		export declare function isSensitiveFieldName(name: string): boolean;
		export declare function hashSensitiveValue(value: string): string;
		export declare function safeStringifyJson(data: any, skippedNames?: Set<string>): string;
		export {};

-529

out/httpExecutor.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.DigestTransform = exports.HttpExecutor = exports.HttpError = void 0;
		exports.addSensitiveRedirectHeader = addSensitiveRedirectHeader;
		exports.addSensitiveFieldPattern = addSensitiveFieldPattern;
		exports.createHttpError = createHttpError;
		exports.parseJson = parseJson;
		exports.configureRequestOptionsFromUrl = configureRequestOptionsFromUrl;
		exports.configureRequestUrl = configureRequestUrl;
		exports.safeGetHeader = safeGetHeader;
		exports.configureRequestOptions = configureRequestOptions;
		exports.isSensitiveFieldName = isSensitiveFieldName;
		exports.hashSensitiveValue = hashSensitiveValue;
		exports.safeStringifyJson = safeStringifyJson;
		const crypto_1 = require("crypto");
		const debug_1 = require("debug");
		const fs_1 = require("fs");
		const stream_1 = require("stream");
		const url_1 = require("url");
		const CancellationToken_1 = require("./CancellationToken");
		const error_1 = require("./error");
		const ProgressCallbackTransform_1 = require("./ProgressCallbackTransform");
		const debug = (0, debug_1.default)("electron-builder");
		// ── Sensitive-data registries ────────────────────────────────────────────────
		// Normalise a header or field name: lowercase + strip all separators (- and _).
		// Shared by both registries so lookup is always separator-agnostic.
		const normalizeName = (name) => name.toLowerCase().replace(/[-_]/g, "");
		// HTTP header names (normalised) stripped on cross-origin redirects.
		// Stored normalised; lookup normalises the incoming key with normalizeName().
		const SENSITIVE_REDIRECT_HEADERS = new Set(["authorization", "proxyauthorization", "privatetoken", "xapikey", "xauthtoken", "xaccesstoken", "xgitlabtoken", "cookie", "xcsrftoken"]);
		// Substrings: a field name containing any of these (after normalization) is redacted.
		const SENSITIVE_FIELD_PATTERNS = ["token", "password", "secret", "authorization", "credential", "apikey", "passphrase", "auth"];
		// Suffixes: a field name ending with any of these (after normalization) is redacted.
		// Intentionally greedy — "publicKey" is also stripped; over-stripping debug logs is
		// acceptable, under-stripping a credential is not.
		const SENSITIVE_FIELD_SUFFIXES = ["key"];
		/**
		* Register an additional HTTP header to strip on cross-origin redirects.
		* Intended for custom publishers (e.g. GenericPublisher with a non-standard auth header).
		*/
		function addSensitiveRedirectHeader(header) {
		SENSITIVE_REDIRECT_HEADERS.add(normalizeName(header));
		}
		/**
		* Register an additional substring pattern used by {@link safeStringifyJson} to
		* identify sensitive field names. Input is normalized (lowercased, separators stripped).
		* Intended for custom publishers that store credentials under non-standard field names.
		*/
		function addSensitiveFieldPattern(pattern) {
		SENSITIVE_FIELD_PATTERNS.push(pattern.toLowerCase().replace(/[-_]/g, ""));
		}
		function createHttpError(response, description = null) {
		return new HttpError(response.statusCode \|\| -1, `${response.statusCode} ${response.statusMessage}` +
		(description == null ? "" : "\n" + JSON.stringify(description, null, " ")) +
		"\nHeaders: " +
		safeStringifyJson(response.headers), description);
		}
		const HTTP_STATUS_CODES = new Map([
		[429, "Too many requests"],
		[400, "Bad request"],
		[403, "Forbidden"],
		[404, "Not found"],
		[405, "Method not allowed"],
		[406, "Not acceptable"],
		[408, "Request timeout"],
		[413, "Request entity too large"],
		[500, "Internal server error"],
		[502, "Bad gateway"],
		[503, "Service unavailable"],
		[504, "Gateway timeout"],
		[505, "HTTP version not supported"],
		]);
		class HttpError extends Error {
		constructor(statusCode, message = `HTTP error: ${HTTP_STATUS_CODES.get(statusCode) \|\| statusCode}`, description = null) {
		super(message);
		this.statusCode = statusCode;
		this.description = description;
		this.name = "HttpError";
		this.code = `HTTP_ERROR_${statusCode}`;
		}
		isServerError() {
		return this.statusCode >= 500 && this.statusCode <= 599;
		}
		}
		exports.HttpError = HttpError;
		function parseJson(result) {
		return result.then(it => (it == null \|\| it.length === 0 ? null : JSON.parse(it)));
		}
		class HttpExecutor {
		constructor() {
		this.maxRedirects = 10;
		}
		request(options, cancellationToken = new CancellationToken_1.CancellationToken(), data) {
		configureRequestOptions(options);
		const json = data == null ? undefined : JSON.stringify(data);
		const encodedData = json ? Buffer.from(json) : undefined;
		if (encodedData != null) {
		if (debug.enabled) {
		debug(safeStringifyJson(data));
		}
		const { headers, ...opts } = options;
		options = {
		method: "post",
		headers: {
		"Content-Type": "application/json",
		"Content-Length": encodedData.length,
		...headers,
		},
		...opts,
		};
		}
		return this.doApiRequest(options, cancellationToken, it => it.end(encodedData));
		}
		doApiRequest(options, cancellationToken, requestProcessor, redirectCount = 0) {
		if (debug.enabled) {
		const { headers: _headers, auth: _auth, ...safeOptions } = options;
		debug(`Request: ${safeStringifyJson(safeOptions)}`);
		}
		return cancellationToken.createPromise((resolve, reject, onCancel) => {
		const request = this.createRequest(options, (response) => {
		try {
		this.handleResponse(response, options, cancellationToken, resolve, reject, redirectCount, requestProcessor);
		}
		catch (e) {
		reject(e);
		}
		});
		this.addErrorAndTimeoutHandlers(request, reject, options.timeout);
		this.addRedirectHandlers(request, options, reject, redirectCount, options => {
		this.doApiRequest(options, cancellationToken, requestProcessor, redirectCount).then(resolve).catch(reject);
		});
		requestProcessor(request, reject);
		onCancel(() => request.abort());
		});
		}
		// noinspection JSUnusedLocalSymbols
		// eslint-disable-next-line
		addRedirectHandlers(request, options, reject, redirectCount, handler) {
		// not required for NodeJS
		}
		addErrorAndTimeoutHandlers(request, reject, timeout = 60 * 1000) {
		this.addTimeOutHandler(request, reject, timeout);
		request.on("error", reject);
		request.on("aborted", () => {
		reject(new Error("Request has been aborted by the server"));
		});
		}
		handleResponse(response, options, cancellationToken, resolve, reject, redirectCount, requestProcessor) {
		var _a;
		if (debug.enabled) {
		const { headers: _headers, auth: _auth, ...safeOptions } = options;
		debug(`Response: ${response.statusCode} ${response.statusMessage}, request options: ${safeStringifyJson(safeOptions)}`);
		}
		// we handle any other >= 400 error on request end (read detailed message in the response body)
		if (response.statusCode === 404) {
		// error is clear, we don't need to read detailed error description
		reject(createHttpError(response, `method: ${options.method \|\| "GET"} url: ${options.protocol \|\| "https:"}//${options.hostname}${options.port ? `:${options.port}` : ""}${options.path}

		Please double check that your authentication token is correct. Due to security reasons, actual status maybe not reported, but 404.
		`));
		return;
		}
		else if (response.statusCode === 204) {
		// on DELETE request
		resolve();
		return;
		}
		const code = (_a = response.statusCode) !== null && _a !== void 0 ? _a : 0;
		const shouldRedirect = code >= 300 && code < 400;
		const redirectUrl = safeGetHeader(response, "location");
		if (shouldRedirect && redirectUrl != null) {
		if (redirectCount > this.maxRedirects) {
		reject(this.createMaxRedirectError());
		return;
		}
		this.doApiRequest(HttpExecutor.prepareRedirectUrlOptions(redirectUrl, options), cancellationToken, requestProcessor, redirectCount).then(resolve).catch(reject);
		return;
		}
		response.setEncoding("utf8");
		let data = "";
		response.on("error", reject);
		response.on("data", (chunk) => (data += chunk));
		response.on("end", () => {
		try {
		if (response.statusCode != null && response.statusCode >= 400) {
		const contentType = safeGetHeader(response, "content-type");
		const isJson = contentType != null && (Array.isArray(contentType) ? contentType.find(it => it.includes("json")) != null : contentType.includes("json"));
		reject(createHttpError(response, `method: ${options.method \|\| "GET"} url: ${options.protocol \|\| "https:"}//${options.hostname}${options.port ? `:${options.port}` : ""}${options.path}

		Data:
		${isJson ? safeStringifyJson(JSON.parse(data)) : data}
		`));
		}
		else {
		resolve(data.length === 0 ? null : data);
		}
		}
		catch (e) {
		reject(e);
		}
		});
		}
		async downloadToBuffer(url, options) {
		return await options.cancellationToken.createPromise((resolve, reject, onCancel) => {
		const responseChunks = [];
		const requestOptions = {
		headers: options.headers \|\| undefined,
		// because PrivateGitHubProvider requires HttpExecutor.prepareRedirectUrlOptions logic, so, we need to redirect manually
		redirect: "manual",
		};
		configureRequestUrl(url, requestOptions);
		configureRequestOptions(requestOptions);
		this.doDownload(requestOptions, {
		destination: null,
		options,
		onCancel,
		callback: error => {
		if (error == null) {
		resolve(Buffer.concat(responseChunks));
		}
		else {
		reject(error);
		}
		},
		responseHandler: (response, callback) => {
		let receivedLength = 0;
		response.on("data", (chunk) => {
		receivedLength += chunk.length;
		if (receivedLength > 524288000) {
		callback(new Error("Maximum allowed size is 500 MB"));
		return;
		}
		responseChunks.push(chunk);
		});
		response.on("end", () => {
		callback(null);
		});
		},
		}, 0);
		});
		}
		doDownload(requestOptions, options, redirectCount) {
		const request = this.createRequest(requestOptions, (response) => {
		if (response.statusCode >= 400) {
		options.callback(new Error(`Cannot download "${requestOptions.protocol \|\| "https:"}//${requestOptions.hostname}${requestOptions.path}", status ${response.statusCode}: ${response.statusMessage}`));
		return;
		}
		// It is possible for the response stream to fail, e.g. when a network is lost while
		// response stream is in progress. Stop waiting and reject so consumer can catch the error.
		response.on("error", options.callback);
		// this code not relevant for Electron (redirect event instead handled)
		const redirectUrl = safeGetHeader(response, "location");
		if (redirectUrl != null) {
		if (redirectCount < this.maxRedirects) {
		this.doDownload(HttpExecutor.prepareRedirectUrlOptions(redirectUrl, requestOptions), options, redirectCount++);
		}
		else {
		options.callback(this.createMaxRedirectError());
		}
		return;
		}
		if (options.responseHandler == null) {
		configurePipes(options, response);
		}
		else {
		options.responseHandler(response, options.callback);
		}
		});
		this.addErrorAndTimeoutHandlers(request, options.callback, requestOptions.timeout);
		this.addRedirectHandlers(request, requestOptions, options.callback, redirectCount, requestOptions => {
		this.doDownload(requestOptions, options, redirectCount++);
		});
		request.end();
		}
		createMaxRedirectError() {
		return new Error(`Too many redirects (> ${this.maxRedirects})`);
		}
		addTimeOutHandler(request, callback, timeout) {
		request.on("socket", (socket) => {
		socket.setTimeout(timeout, () => {
		request.abort();
		callback(new Error("Request timed out"));
		});
		});
		}
		static prepareRedirectUrlOptions(redirectUrl, options) {
		const newOptions = configureRequestOptionsFromUrl(redirectUrl, { ...options });
		const headers = newOptions.headers;
		if (headers == null) {
		return newOptions;
		}
		const originalUrl = HttpExecutor.reconstructOriginalUrl(options);
		const parsedRedirectUrl = parseUrl(redirectUrl, options);
		if (HttpExecutor.isCrossOriginRedirect(originalUrl, parsedRedirectUrl)) {
		if (debug.enabled) {
		debug(`Cross-origin redirect (${originalUrl.host} → ${parsedRedirectUrl.host}): stripping sensitive headers`);
		}
		for (const key of Object.keys(headers)) {
		if (SENSITIVE_REDIRECT_HEADERS.has(normalizeName(key))) {
		delete headers[key];
		}
		}
		}
		return newOptions;
		}
		static reconstructOriginalUrl(options) {
		const protocol = options.protocol \|\| "https:";
		if (!options.hostname) {
		throw new Error("Missing hostname in request options");
		}
		const hostname = options.hostname;
		const port = options.port ? `:${options.port}` : "";
		const path = options.path \|\| "/";
		return new url_1.URL(`${protocol}//${hostname}${port}${path}`);
		}
		static isCrossOriginRedirect(originalUrl, redirectUrl) {
		// Case-insensitive hostname comparison
		if (originalUrl.hostname.toLowerCase() !== redirectUrl.hostname.toLowerCase()) {
		return true;
		}
		// Special case: allow http -> https redirect on same host with standard ports
		// This matches the behavior of Python requests library for backward compatibility
		// url.port returns an empty string if the port is omitted
		// or explicitly set to the default port for a given protocol.
		if (originalUrl.protocol === "http:" &&
		// This can be replaced with `!originalUrl.port`, but for the sake of clarity.
		["80", ""].includes(originalUrl.port) &&
		redirectUrl.protocol === "https:" &&
		// This can be replaced with `!redirectUrl.port`, but for the sake of clarity.
		["443", ""].includes(redirectUrl.port)) {
		return false;
		}
		// According to RFC 7235, a change in protocol or port constitutes a cross-origin request.
		// Forwarding authentication headers to a different origin can be a security risk.
		// For example, https://example.com:443 and http://example.com:80 are different origins.
		// We only make an exception for HTTP -> HTTPS upgrades on standard ports for backward compatibility.
		// Strip auth on any other protocol change
		if (originalUrl.protocol !== redirectUrl.protocol) {
		return true;
		}
		// Strip auth on port change (accounting for default ports)
		const originalPort = originalUrl.port;
		const redirectPort = redirectUrl.port;
		return originalPort !== redirectPort;
		}
		static async retryOnServerError(task, maxRetries = 3) {
		for (let attemptNumber = 0;; attemptNumber++) {
		try {
		return await task();
		}
		catch (e) {
		if (attemptNumber < maxRetries && ((e instanceof HttpError && e.isServerError()) \|\| e.code === "EPIPE")) {
		await new Promise(r => setTimeout(r, 1000 * (attemptNumber + 1)));
		continue;
		}
		throw e;
		}
		}
		}
		}
		exports.HttpExecutor = HttpExecutor;
		function parseUrl(url, options) {
		try {
		// Would throw exception if url is not absolute
		return new url_1.URL(url);
		}
		catch {
		// Relative URL - construct base URL from original options
		const hostname = options.hostname;
		const protocol = options.protocol \|\| "https:";
		const port = options.port ? `:${options.port}` : "";
		const baseUrl = `${protocol}//${hostname}${port}`;
		return new url_1.URL(url, baseUrl);
		}
		}
		function configureRequestOptionsFromUrl(url, options) {
		const result = configureRequestOptions(options);
		const parsedUrl = parseUrl(url, options);
		configureRequestUrl(parsedUrl, result);
		return result;
		}
		function configureRequestUrl(url, options) {
		options.protocol = url.protocol;
		options.hostname = url.hostname;
		if (url.port) {
		options.port = url.port;
		}
		else if (options.port) {
		delete options.port;
		}
		options.path = url.pathname + url.search;
		}
		class DigestTransform extends stream_1.Transform {
		// noinspection JSUnusedGlobalSymbols
		get actual() {
		return this._actual;
		}
		constructor(expected, algorithm = "sha512", encoding = "base64") {
		super();
		this.expected = expected;
		this.algorithm = algorithm;
		this.encoding = encoding;
		this._actual = null;
		this.isValidateOnEnd = true;
		this.digester = (0, crypto_1.createHash)(algorithm);
		}
		// noinspection JSUnusedGlobalSymbols
		_transform(chunk, encoding, callback) {
		this.digester.update(chunk);
		callback(null, chunk);
		}
		// noinspection JSUnusedGlobalSymbols
		_flush(callback) {
		this._actual = this.digester.digest(this.encoding);
		if (this.isValidateOnEnd) {
		try {
		this.validate();
		}
		catch (e) {
		callback(e);
		return;
		}
		}
		callback(null);
		}
		validate() {
		if (this._actual == null) {
		throw (0, error_1.newError)("Not finished yet", "ERR_STREAM_NOT_FINISHED");
		}
		if (this._actual !== this.expected) {
		throw (0, error_1.newError)(`${this.algorithm} checksum mismatch, expected ${this.expected}, got ${this._actual}`, "ERR_CHECKSUM_MISMATCH");
		}
		return null;
		}
		}
		exports.DigestTransform = DigestTransform;
		function checkSha2(sha2Header, sha2, callback) {
		if (sha2Header != null && sha2 != null && sha2Header !== sha2) {
		callback(new Error(`checksum mismatch: expected ${sha2} but got ${sha2Header} (X-Checksum-Sha2 header)`));
		return false;
		}
		return true;
		}
		function safeGetHeader(response, headerKey) {
		const value = response.headers[headerKey];
		if (value == null) {
		return null;
		}
		else if (Array.isArray(value)) {
		// electron API
		return value.length === 0 ? null : value[value.length - 1];
		}
		else {
		return value;
		}
		}
		function configurePipes(options, response) {
		if (!checkSha2(safeGetHeader(response, "X-Checksum-Sha2"), options.options.sha2, options.callback)) {
		return;
		}
		const streams = [];
		if (options.options.onProgress != null) {
		const contentLength = safeGetHeader(response, "content-length");
		if (contentLength != null) {
		streams.push(new ProgressCallbackTransform_1.ProgressCallbackTransform(parseInt(contentLength, 10), options.options.cancellationToken, options.options.onProgress));
		}
		}
		const sha512 = options.options.sha512;
		if (sha512 != null) {
		streams.push(new DigestTransform(sha512, "sha512", sha512.length === 128 && !sha512.includes("+") && !sha512.includes("Z") && !sha512.includes("=") ? "hex" : "base64"));
		}
		else if (options.options.sha2 != null) {
		streams.push(new DigestTransform(options.options.sha2, "sha256", "hex"));
		}
		const fileOut = (0, fs_1.createWriteStream)(options.destination);
		streams.push(fileOut);
		let lastStream = response;
		for (const stream of streams) {
		stream.on("error", (error) => {
		fileOut.close();
		if (!options.options.cancellationToken.cancelled) {
		options.callback(error);
		}
		});
		lastStream = lastStream.pipe(stream);
		}
		fileOut.on("finish", () => {
		;
		fileOut.close(options.callback);
		});
		}
		function configureRequestOptions(options, token, method) {
		if (method != null) {
		options.method = method;
		}
		options.headers = { ...options.headers };
		const headers = options.headers;
		if (token != null) {
		;
		headers.authorization = token.startsWith("Basic") \|\| token.startsWith("Bearer") ? token : `token ${token}`;
		}
		if (headers["User-Agent"] == null) {
		headers["User-Agent"] = "electron-builder";
		}
		if (method == null \|\| method === "GET" \|\| headers["Cache-Control"] == null) {
		headers["Cache-Control"] = "no-cache";
		}
		// do not specify for node (in any case we use https module)
		if (options.protocol == null && process.versions.electron != null) {
		options.protocol = "https:";
		}
		return options;
		}
		function isSensitiveFieldName(name) {
		const normalized = normalizeName(name);
		return SENSITIVE_FIELD_PATTERNS.some(p => normalized.includes(p)) \|\| SENSITIVE_FIELD_SUFFIXES.some(s => normalized.endsWith(s));
		}
		function hashSensitiveValue(value) {
		return `${(0, crypto_1.createHash)("sha256").update(value).digest("hex")} (sha256 hash)`;
		}
		function safeStringifyJson(data, skippedNames) {
		return JSON.stringify(data, (name, value) => {
		if (isSensitiveFieldName(name) \|\| (skippedNames != null && skippedNames.has(name))) {
		return typeof value === "string" ? hashSensitiveValue(value) : "<stripped sensitive data>";
		}
		return value;
		}, 2);
		}
		//# sourceMappingURL=httpExecutor.js.map

-1

out/httpExecutor.js.map

-15

out/index.d.ts

		export { BlockMap } from "./blockMapApi";
		export { CancellationError, CancellationToken } from "./CancellationToken";
		export { newError } from "./error";
		export { configureRequestOptions, configureRequestOptionsFromUrl, configureRequestUrl, createHttpError, DigestTransform, DownloadOptions, HttpError, hashSensitiveValue, HttpExecutor, isSensitiveFieldName, parseJson, RequestHeaders, safeGetHeader, safeStringifyJson, } from "./httpExecutor";
		export { MemoLazy } from "./MemoLazy";
		export { ProgressCallbackTransform, ProgressInfo } from "./ProgressCallbackTransform";
		export { AllPublishOptions, BaseS3Options, BitbucketOptions, CustomPublishOptions, GenericServerOptions, getS3LikeProviderBaseUrl, GithubOptions, githubUrl, githubTagPrefix, GitlabOptions, KeygenOptions, PublishConfiguration, PublishProvider, S3Options, SnapStoreOptions, SpacesOptions, GitlabReleaseInfo, GitlabReleaseAsset, } from "./publishOptions";
		export { retry } from "./retry";
		export { parseDn } from "./rfc2253Parser";
		export { BlockMapDataHolder, PackageFileInfo, ReleaseNoteInfo, UpdateFileInfo, UpdateInfo, WindowsUpdateInfo } from "./updateInfo";
		export { UUID } from "./uuid";
		export { parseXml, XElement } from "./xml";
		export { isValidKey, mapToObject, asArray, Nullish, deepAssign, objectToArgs } from "./objects";
		export declare const CURRENT_APP_INSTALLER_FILE_NAME = "installer.exe";
		export declare const CURRENT_APP_PACKAGE_FILE_NAME = "package.7z";

-49

out/index.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.CURRENT_APP_PACKAGE_FILE_NAME = exports.CURRENT_APP_INSTALLER_FILE_NAME = exports.objectToArgs = exports.deepAssign = exports.asArray = exports.mapToObject = exports.isValidKey = exports.XElement = exports.parseXml = exports.UUID = exports.parseDn = exports.retry = exports.githubTagPrefix = exports.githubUrl = exports.getS3LikeProviderBaseUrl = exports.ProgressCallbackTransform = exports.MemoLazy = exports.safeStringifyJson = exports.safeGetHeader = exports.parseJson = exports.isSensitiveFieldName = exports.HttpExecutor = exports.hashSensitiveValue = exports.HttpError = exports.DigestTransform = exports.createHttpError = exports.configureRequestUrl = exports.configureRequestOptionsFromUrl = exports.configureRequestOptions = exports.newError = exports.CancellationToken = exports.CancellationError = void 0;
		var CancellationToken_1 = require("./CancellationToken");
		Object.defineProperty(exports, "CancellationError", { enumerable: true, get: function () { return CancellationToken_1.CancellationError; } });
		Object.defineProperty(exports, "CancellationToken", { enumerable: true, get: function () { return CancellationToken_1.CancellationToken; } });
		var error_1 = require("./error");
		Object.defineProperty(exports, "newError", { enumerable: true, get: function () { return error_1.newError; } });
		var httpExecutor_1 = require("./httpExecutor");
		Object.defineProperty(exports, "configureRequestOptions", { enumerable: true, get: function () { return httpExecutor_1.configureRequestOptions; } });
		Object.defineProperty(exports, "configureRequestOptionsFromUrl", { enumerable: true, get: function () { return httpExecutor_1.configureRequestOptionsFromUrl; } });
		Object.defineProperty(exports, "configureRequestUrl", { enumerable: true, get: function () { return httpExecutor_1.configureRequestUrl; } });
		Object.defineProperty(exports, "createHttpError", { enumerable: true, get: function () { return httpExecutor_1.createHttpError; } });
		Object.defineProperty(exports, "DigestTransform", { enumerable: true, get: function () { return httpExecutor_1.DigestTransform; } });
		Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return httpExecutor_1.HttpError; } });
		Object.defineProperty(exports, "hashSensitiveValue", { enumerable: true, get: function () { return httpExecutor_1.hashSensitiveValue; } });
		Object.defineProperty(exports, "HttpExecutor", { enumerable: true, get: function () { return httpExecutor_1.HttpExecutor; } });
		Object.defineProperty(exports, "isSensitiveFieldName", { enumerable: true, get: function () { return httpExecutor_1.isSensitiveFieldName; } });
		Object.defineProperty(exports, "parseJson", { enumerable: true, get: function () { return httpExecutor_1.parseJson; } });
		Object.defineProperty(exports, "safeGetHeader", { enumerable: true, get: function () { return httpExecutor_1.safeGetHeader; } });
		Object.defineProperty(exports, "safeStringifyJson", { enumerable: true, get: function () { return httpExecutor_1.safeStringifyJson; } });
		var MemoLazy_1 = require("./MemoLazy");
		Object.defineProperty(exports, "MemoLazy", { enumerable: true, get: function () { return MemoLazy_1.MemoLazy; } });
		var ProgressCallbackTransform_1 = require("./ProgressCallbackTransform");
		Object.defineProperty(exports, "ProgressCallbackTransform", { enumerable: true, get: function () { return ProgressCallbackTransform_1.ProgressCallbackTransform; } });
		var publishOptions_1 = require("./publishOptions");
		Object.defineProperty(exports, "getS3LikeProviderBaseUrl", { enumerable: true, get: function () { return publishOptions_1.getS3LikeProviderBaseUrl; } });
		Object.defineProperty(exports, "githubUrl", { enumerable: true, get: function () { return publishOptions_1.githubUrl; } });
		Object.defineProperty(exports, "githubTagPrefix", { enumerable: true, get: function () { return publishOptions_1.githubTagPrefix; } });
		var retry_1 = require("./retry");
		Object.defineProperty(exports, "retry", { enumerable: true, get: function () { return retry_1.retry; } });
		var rfc2253Parser_1 = require("./rfc2253Parser");
		Object.defineProperty(exports, "parseDn", { enumerable: true, get: function () { return rfc2253Parser_1.parseDn; } });
		var uuid_1 = require("./uuid");
		Object.defineProperty(exports, "UUID", { enumerable: true, get: function () { return uuid_1.UUID; } });
		var xml_1 = require("./xml");
		Object.defineProperty(exports, "parseXml", { enumerable: true, get: function () { return xml_1.parseXml; } });
		Object.defineProperty(exports, "XElement", { enumerable: true, get: function () { return xml_1.XElement; } });
		var objects_1 = require("./objects");
		Object.defineProperty(exports, "isValidKey", { enumerable: true, get: function () { return objects_1.isValidKey; } });
		Object.defineProperty(exports, "mapToObject", { enumerable: true, get: function () { return objects_1.mapToObject; } });
		Object.defineProperty(exports, "asArray", { enumerable: true, get: function () { return objects_1.asArray; } });
		Object.defineProperty(exports, "deepAssign", { enumerable: true, get: function () { return objects_1.deepAssign; } });
		Object.defineProperty(exports, "objectToArgs", { enumerable: true, get: function () { return objects_1.objectToArgs; } });
		// nsis
		exports.CURRENT_APP_INSTALLER_FILE_NAME = "installer.exe";
		// nsis-web
		exports.CURRENT_APP_PACKAGE_FILE_NAME = "package.7z";
		//# sourceMappingURL=index.js.map

-1

out/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AACA,yDAA0E;AAAjE,sHAAA,iBAAiB,OAAA;AAAE,sHAAA,iBAAiB,OAAA;AAC7C,iCAAkC;AAAzB,iGAAA,QAAQ,OAAA;AACjB,+CAeuB;AAdrB,uHAAA,uBAAuB,OAAA;AACvB,8HAAA,8BAA8B,OAAA;AAC9B,mHAAA,mBAAmB,OAAA;AACnB,+GAAA,eAAe,OAAA;AACf,+GAAA,eAAe,OAAA;AAEf,yGAAA,SAAS,OAAA;AACT,kHAAA,kBAAkB,OAAA;AAClB,4GAAA,YAAY,OAAA;AACZ,oHAAA,oBAAoB,OAAA;AACpB,yGAAA,SAAS,OAAA;AAET,6GAAA,aAAa,OAAA;AACb,iHAAA,iBAAiB,OAAA;AAEnB,uCAAqC;AAA5B,oGAAA,QAAQ,OAAA;AACjB,yEAAqF;AAA5E,sIAAA,yBAAyB,OAAA;AAClC,mDAmByB;AAbvB,0HAAA,wBAAwB,OAAA;AAExB,2GAAA,SAAS,OAAA;AACT,iHAAA,eAAe,OAAA;AAWjB,iCAA+B;AAAtB,8FAAA,KAAK,OAAA;AACd,iDAAyC;AAAhC,wGAAA,OAAO,OAAA;AAEhB,+BAA6B;AAApB,4FAAA,IAAI,OAAA;AACb,6BAA0C;AAAjC,+FAAA,QAAQ,OAAA;AAAE,+FAAA,QAAQ,OAAA;AAC3B,qCAA+F;AAAtF,qGAAA,UAAU,OAAA;AAAE,sGAAA,WAAW,OAAA;AAAE,kGAAA,OAAO,OAAA;AAAW,qGAAA,UAAU,OAAA;AAAE,uGAAA,YAAY,OAAA;AAE5E,OAAO;AACM,QAAA,+BAA+B,GAAG,eAAe,CAAA;AAC9D,WAAW;AACE,QAAA,6BAA6B,GAAG,YAAY,CAAA","sourcesContent":["export { BlockMap } from \"./blockMapApi\"\nexport { CancellationError, CancellationToken } from \"./CancellationToken\"\nexport { newError } from \"./error\"\nexport {\n configureRequestOptions,\n configureRequestOptionsFromUrl,\n configureRequestUrl,\n createHttpError,\n DigestTransform,\n DownloadOptions,\n HttpError,\n hashSensitiveValue,\n HttpExecutor,\n isSensitiveFieldName,\n parseJson,\n RequestHeaders,\n safeGetHeader,\n safeStringifyJson,\n} from \"./httpExecutor\"\nexport { MemoLazy } from \"./MemoLazy\"\nexport { ProgressCallbackTransform, ProgressInfo } from \"./ProgressCallbackTransform\"\nexport {\n AllPublishOptions,\n BaseS3Options,\n BitbucketOptions,\n CustomPublishOptions,\n GenericServerOptions,\n getS3LikeProviderBaseUrl,\n GithubOptions,\n githubUrl,\n githubTagPrefix,\n GitlabOptions,\n KeygenOptions,\n PublishConfiguration,\n PublishProvider,\n S3Options,\n SnapStoreOptions,\n SpacesOptions,\n GitlabReleaseInfo,\n GitlabReleaseAsset,\n} from \"./publishOptions\"\nexport { retry } from \"./retry\"\nexport { parseDn } from \"./rfc2253Parser\"\nexport { BlockMapDataHolder, PackageFileInfo, ReleaseNoteInfo, UpdateFileInfo, UpdateInfo, WindowsUpdateInfo } from \"./updateInfo\"\nexport { UUID } from \"./uuid\"\nexport { parseXml, XElement } from \"./xml\"\nexport { isValidKey, mapToObject, asArray, Nullish, deepAssign, objectToArgs } from \"./objects\"\n\n// nsis\nexport const CURRENT_APP_INSTALLER_FILE_NAME = \"installer.exe\"\n// nsis-web\nexport const CURRENT_APP_PACKAGE_FILE_NAME = \"package.7z\"\n"]}

-10

out/MemoLazy.d.ts

		export declare class MemoLazy<S, V> {
		private selector;
		private creator;
		private selected;
		private _value;
		constructor(selector: () => S, creator: (selected: S) => Promise<V>);
		get hasValue(): boolean;
		get value(): Promise<V>;
		set value(value: Promise<V>);
		}

-42

out/MemoLazy.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.MemoLazy = void 0;
		class MemoLazy {
		constructor(selector, creator) {
		this.selector = selector;
		this.creator = creator;
		this.selected = undefined;
		this._value = undefined;
		}
		get hasValue() {
		return this._value !== undefined;
		}
		get value() {
		const selected = this.selector();
		if (this._value !== undefined && equals(this.selected, selected)) {
		// value exists and selected hasn't changed, so return the cached value
		return this._value;
		}
		this.selected = selected;
		const result = this.creator(selected);
		this.value = result;
		return result;
		}
		set value(value) {
		this._value = value;
		}
		}
		exports.MemoLazy = MemoLazy;
		function equals(firstValue, secondValue) {
		const isFirstObject = typeof firstValue === "object" && firstValue !== null;
		const isSecondObject = typeof secondValue === "object" && secondValue !== null;
		// do a shallow comparison of objects, arrays etc.
		if (isFirstObject && isSecondObject) {
		const keys1 = Object.keys(firstValue);
		const keys2 = Object.keys(secondValue);
		return keys1.length === keys2.length && keys1.every((key) => equals(firstValue[key], secondValue[key]));
		}
		// otherwise just compare the values directly
		return firstValue === secondValue;
		}
		//# sourceMappingURL=MemoLazy.js.map

-1

out/MemoLazy.js.map

{"version":3,"file":"MemoLazy.js","sourceRoot":"","sources":["../src/MemoLazy.ts"],"names":[],"mappings":";;;AAAA,MAAa,QAAQ;IAInB,YACU,QAAiB,EACjB,OAAoC;QADpC,aAAQ,GAAR,QAAQ,CAAS;QACjB,YAAO,GAAP,OAAO,CAA6B;QALtC,aAAQ,GAAkB,SAAS,CAAA;QACnC,WAAM,GAA2B,SAAS,CAAA;IAK/C,CAAC;IAEJ,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,CAAA;IAClC,CAAC;IAED,IAAI,KAAK;QACP,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAA;QAChC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC;YACjE,uEAAuE;YACvE,OAAO,IAAI,CAAC,MAAM,CAAA;QACpB,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;QACrC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAA;QAEnB,OAAO,MAAM,CAAA;IACf,CAAC;IAED,IAAI,KAAK,CAAC,KAAiB;QACzB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;IACrB,CAAC;CACF;AA9BD,4BA8BC;AAED,SAAS,MAAM,CAAC,UAAe,EAAE,WAAgB;IAC/C,MAAM,aAAa,GAAG,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,IAAI,CAAA;IAC3E,MAAM,cAAc,GAAG,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,IAAI,CAAA;IAE9E,kDAAkD;IAClD,IAAI,aAAa,IAAI,cAAc,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QACrC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QAEtC,OAAO,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IAC9G,CAAC;IAED,6CAA6C;IAC7C,OAAO,UAAU,KAAK,WAAW,CAAA;AACnC,CAAC","sourcesContent":["export class MemoLazy<S, V> {\n private selected: S | undefined = undefined\n private _value: Promise<V> | undefined = undefined\n\n constructor(\n private selector: () => S,\n private creator: (selected: S) => Promise<V>\n ) {}\n\n get hasValue() {\n return this._value !== undefined\n }\n\n get value(): Promise<V> {\n const selected = this.selector()\n if (this._value !== undefined && equals(this.selected, selected)) {\n // value exists and selected hasn't changed, so return the cached value\n return this._value\n }\n\n this.selected = selected\n const result = this.creator(selected)\n this.value = result\n\n return result\n }\n\n set value(value: Promise<V>) {\n this._value = value\n }\n}\n\nfunction equals(firstValue: any, secondValue: any): boolean {\n const isFirstObject = typeof firstValue === \"object\" && firstValue !== null\n const isSecondObject = typeof secondValue === \"object\" && secondValue !== null\n\n // do a shallow comparison of objects, arrays etc.\n if (isFirstObject && isSecondObject) {\n const keys1 = Object.keys(firstValue)\n const keys2 = Object.keys(secondValue)\n\n return keys1.length === keys2.length && keys1.every((key: any) => equals(firstValue[key], secondValue[key]))\n }\n\n // otherwise just compare the values directly\n return firstValue === secondValue\n}\n"]}

-8

out/objects.d.ts

		export type Nullish = null \| undefined;
		type RecursiveMap = Map<any, RecursiveMap \| any>;
		export declare function mapToObject(map: RecursiveMap): any;
		export declare function isValidKey(key: any): boolean;
		export declare function asArray<T>(v: Nullish \| T \| Array<T>): Array<T>;
		export declare function deepAssign<T>(target: T, ...objects: Array<any>): T;
		export declare function objectToArgs(obj: Record<string, string \| null>): readonly string[];
		export {};

-106

out/objects.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.mapToObject = mapToObject;
		exports.isValidKey = isValidKey;
		exports.asArray = asArray;
		exports.deepAssign = deepAssign;
		exports.objectToArgs = objectToArgs;
		function mapToObject(map) {
		const obj = {};
		for (const [key, value] of map) {
		if (!isValidKey(key)) {
		continue;
		}
		if (value instanceof Map) {
		obj[key] = mapToObject(value);
		}
		else {
		obj[key] = value;
		}
		}
		return obj;
		}
		function isValidKey(key) {
		const protectedProperties = ["__proto__", "prototype", "constructor"];
		if (protectedProperties.includes(key)) {
		return false;
		}
		return ["string", "number", "symbol", "boolean"].includes(typeof key) \|\| key === null;
		}
		function asArray(v) {
		if (v == null) {
		return [];
		}
		else if (Array.isArray(v)) {
		return v;
		}
		else {
		return [v];
		}
		}
		function isObject(x) {
		if (Array.isArray(x)) {
		return false;
		}
		const type = typeof x;
		return type === "object" \|\| type === "function";
		}
		function assignKey(target, from, key) {
		const value = from[key];
		// https://github.com/electron-userland/electron-builder/pull/562
		if (value === undefined) {
		return;
		}
		const prevValue = target[key];
		if (prevValue == null \|\| value == null \|\| !isObject(prevValue) \|\| !isObject(value)) {
		// Merge arrays.
		if (Array.isArray(prevValue) && Array.isArray(value)) {
		target[key] = Array.from(new Set(prevValue.concat(value)));
		}
		else {
		target[key] = value;
		}
		}
		else {
		target[key] = assign(prevValue, value);
		}
		}
		function assign(to, from) {
		if (to !== from) {
		for (const key of Object.getOwnPropertyNames(from)) {
		if (isValidKey(key)) {
		assignKey(to, from, key);
		}
		}
		}
		return to;
		}
		function deepAssign(target, ...objects) {
		for (const o of objects) {
		if (o != null) {
		assign(target, o);
		}
		}
		return target;
		}
		// Flag names must be letters/digits/hyphens only (e.g. "maintainer", "deb-priority").
		// Anything else could inject extra flags into the argument array.
		const SAFE_FLAG_NAME_RE = /^[a-zA-Z][a-zA-Z0-9-]*$/;
		// Null bytes truncate arguments at the C layer; newlines can split arguments in some parsers.
		const UNSAFE_VALUE_RE = /[\0\r\n]/;
		function objectToArgs(obj) {
		const args = Object.entries(obj).reduce((args, [name, value]) => {
		if (!isValidKey(name) \|\| value == null) {
		return args;
		}
		if (!SAFE_FLAG_NAME_RE.test(name)) {
		throw new Error(`objectToArgs: unsafe flag name rejected: ${JSON.stringify(name)}`);
		}
		if (UNSAFE_VALUE_RE.test(value)) {
		throw new Error(`objectToArgs: value for --${name} contains a null byte or newline`);
		}
		return args.concat([`--${name}`, value]);
		}, []);
		return Object.freeze(args);
		}
		//# sourceMappingURL=objects.js.map

-1

out/objects.js.map

-21

out/ProgressCallbackTransform.d.ts

		import { Transform } from "stream";
		import { CancellationToken } from "./CancellationToken";
		export interface ProgressInfo {
		total: number;
		delta: number;
		transferred: number;
		percent: number;
		bytesPerSecond: number;
		}
		export declare class ProgressCallbackTransform extends Transform {
		private readonly total;
		private readonly cancellationToken;
		private readonly onProgress;
		private start;
		private transferred;
		private delta;
		private nextUpdate;
		constructor(total: number, cancellationToken: CancellationToken, onProgress: (info: ProgressInfo) => any);
		_transform(chunk: any, encoding: string, callback: any): void;
		_flush(callback: any): void;
		}

-54

out/ProgressCallbackTransform.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.ProgressCallbackTransform = void 0;
		const stream_1 = require("stream");
		class ProgressCallbackTransform extends stream_1.Transform {
		constructor(total, cancellationToken, onProgress) {
		super();
		this.total = total;
		this.cancellationToken = cancellationToken;
		this.onProgress = onProgress;
		this.start = Date.now();
		this.transferred = 0;
		this.delta = 0;
		this.nextUpdate = this.start + 1000;
		}
		_transform(chunk, encoding, callback) {
		if (this.cancellationToken.cancelled) {
		callback(new Error("cancelled"), null);
		return;
		}
		this.transferred += chunk.length;
		this.delta += chunk.length;
		const now = Date.now();
		if (now >= this.nextUpdate && this.transferred !== this.total /* will be emitted on _flush */) {
		this.nextUpdate = now + 1000;
		this.onProgress({
		total: this.total,
		delta: this.delta,
		transferred: this.transferred,
		percent: (this.transferred / this.total) * 100,
		bytesPerSecond: Math.round(this.transferred / ((now - this.start) / 1000)),
		});
		this.delta = 0;
		}
		callback(null, chunk);
		}
		_flush(callback) {
		if (this.cancellationToken.cancelled) {
		callback(new Error("cancelled"));
		return;
		}
		this.onProgress({
		total: this.total,
		delta: this.delta,
		transferred: this.total,
		percent: 100,
		bytesPerSecond: Math.round(this.transferred / ((Date.now() - this.start) / 1000)),
		});
		this.delta = 0;
		callback(null);
		}
		}
		exports.ProgressCallbackTransform = ProgressCallbackTransform;
		//# sourceMappingURL=ProgressCallbackTransform.js.map

-1

out/ProgressCallbackTransform.js.map

{"version":3,"file":"ProgressCallbackTransform.js","sourceRoot":"","sources":["../src/ProgressCallbackTransform.ts"],"names":[],"mappings":";;;AAAA,mCAAkC;AAWlC,MAAa,yBAA0B,SAAQ,kBAAS;IAOtD,YACmB,KAAa,EACb,iBAAoC,EACpC,UAAuC;QAExD,KAAK,EAAE,CAAA;QAJU,UAAK,GAAL,KAAK,CAAQ;QACb,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,eAAU,GAAV,UAAU,CAA6B;QATlD,UAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QAClB,gBAAW,GAAG,CAAC,CAAA;QACf,UAAK,GAAG,CAAC,CAAA;QAET,eAAU,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IAQtC,CAAC;IAED,UAAU,CAAC,KAAU,EAAE,QAAgB,EAAE,QAAa;QACpD,IAAI,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YACrC,QAAQ,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAA;YACtC,OAAM;QACR,CAAC;QAED,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,MAAM,CAAA;QAChC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,CAAA;QAE1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QACtB,IAAI,GAAG,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,KAAK,CAAC,+BAA+B,EAAE,CAAC;YAC9F,IAAI,CAAC,UAAU,GAAG,GAAG,GAAG,IAAI,CAAA;YAE5B,IAAI,CAAC,UAAU,CAAC;gBACd,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,OAAO,EAAE,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG;gBAC9C,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;aAC3E,CAAC,CAAA;YACF,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QAChB,CAAC;QAED,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IACvB,CAAC;IAED,MAAM,CAAC,QAAa;QAClB,IAAI,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YACrC,QAAQ,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,CAAA;YAChC,OAAM;QACR,CAAC;QAED,IAAI,CAAC,UAAU,CAAC;YACd,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,KAAK;YACvB,OAAO,EAAE,GAAG;YACZ,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;SAClF,CAAC,CAAA;QACF,IAAI,CAAC,KAAK,GAAG,CAAC,CAAA;QAEd,QAAQ,CAAC,IAAI,CAAC,CAAA;IAChB,CAAC;CACF;AA1DD,8DA0DC","sourcesContent":["import { Transform } from \"stream\"\nimport { CancellationToken } from \"./CancellationToken\"\n\nexport interface ProgressInfo {\n total: number\n delta: number\n transferred: number\n percent: number\n bytesPerSecond: number\n}\n\nexport class ProgressCallbackTransform extends Transform {\n private start = Date.now()\n private transferred = 0\n private delta = 0\n\n private nextUpdate = this.start + 1000\n\n constructor(\n private readonly total: number,\n private readonly cancellationToken: CancellationToken,\n private readonly onProgress: (info: ProgressInfo) => any\n ) {\n super()\n }\n\n _transform(chunk: any, encoding: string, callback: any) {\n if (this.cancellationToken.cancelled) {\n callback(new Error(\"cancelled\"), null)\n return\n }\n\n this.transferred += chunk.length\n this.delta += chunk.length\n\n const now = Date.now()\n if (now >= this.nextUpdate && this.transferred !== this.total /* will be emitted on _flush */) {\n this.nextUpdate = now + 1000\n\n this.onProgress({\n total: this.total,\n delta: this.delta,\n transferred: this.transferred,\n percent: (this.transferred / this.total) * 100,\n bytesPerSecond: Math.round(this.transferred / ((now - this.start) / 1000)),\n })\n this.delta = 0\n }\n\n callback(null, chunk)\n }\n\n _flush(callback: any): void {\n if (this.cancellationToken.cancelled) {\n callback(new Error(\"cancelled\"))\n return\n }\n\n this.onProgress({\n total: this.total,\n delta: this.delta,\n transferred: this.total,\n percent: 100,\n bytesPerSecond: Math.round(this.transferred / ((Date.now() - this.start) / 1000)),\n })\n this.delta = 0\n\n callback(null)\n }\n}\n"]}

-396

out/publishOptions.d.ts

		import { OutgoingHttpHeaders } from "http";
		export type PublishProvider = "github" \| "gitlab" \| "s3" \| "spaces" \| "generic" \| "custom" \| "snapStore" \| "keygen" \| "bitbucket";
		export type AllPublishOptions = string \| GithubOptions \| GitlabOptions \| S3Options \| SpacesOptions \| GenericServerOptions \| CustomPublishOptions \| KeygenOptions \| SnapStoreOptions \| BitbucketOptions;
		export interface PublishConfiguration {
		/**
		* The provider.
		*/
		readonly provider: PublishProvider;
		/**
		* @private
		* win-only
		*/
		publisherName?: Array<string> \| null;
		/**
		* @private
		* win-only
		*/
		readonly updaterCacheDirName?: string \| null;
		/**
		* Whether to publish auto update info files.
		*
		* Auto update relies only on the first provider in the list (you can specify several publishers).
		* Thus, probably, there`s no need to upload the metadata files for the other configured providers. But by default will be uploaded.
		*
		* @default true
		*/
		readonly publishAutoUpdate?: boolean;
		/**
		* Any custom request headers
		*/
		readonly requestHeaders?: OutgoingHttpHeaders;
		/**
		* Request timeout in milliseconds. (Default is 2 minutes; O is ignored)
		*
		* @default 120000
		*/
		readonly timeout?: number \| null;
		}
		export interface CustomPublishOptions extends PublishConfiguration {
		/**
		* The provider. Must be `custom`.
		*/
		readonly provider: "custom";
		/**
		* The Provider to provide UpdateInfo regarding available updates. Required
		* to use custom providers with electron-updater.
		*/
		updateProvider?: new (options: CustomPublishOptions, updater: any, runtimeOptions: any) => any;
		[index: string]: any;
		}
		/**
		* [GitHub](https://help.github.com/articles/about-releases/) options.
		*
		* GitHub [personal access token](https://help.github.com/articles/creating-an-access-token-for-command-line-use/) is required. You can generate by going to [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new). The access token should have the repo scope/permission.
		* Define `GH_TOKEN` environment variable.
		*/
		export interface GithubOptions extends PublishConfiguration {
		/**
		* The provider. Must be `github`.
		*/
		readonly provider: "github";
		/**
		* The repository name. [Detected automatically](#github-repository-and-bintray-package).
		*/
		readonly repo?: string \| null;
		/**
		* The owner.
		*/
		readonly owner?: string \| null;
		/**
		* Whether to use `v`-prefixed tag name.
		* @default true
		* @deprecated please use #tagNamePrefix instead.
		*/
		readonly vPrefixedTagName?: boolean;
		/**
		* If defined, sets the prefix of the tag name that comes before the semver number.
		* e.g. "v" in "v1.2.3" or "test" of "test1.2.3".
		* Overrides `vPrefixedTagName`
		*/
		readonly tagNamePrefix?: string;
		/**
		* The host (including the port if need).
		* @default github.com
		*/
		readonly host?: string \| null;
		/**
		* The protocol. GitHub Publisher supports only `https`.
		* @default https
		*/
		readonly protocol?: "https" \| "http" \| null;
		/**
		* The access token to support auto-update from private github repositories. Never specify it in the configuration files. Only for [setFeedURL](https://www.electron.build/auto-update#appupdatersetfeedurloptions).
		*/
		readonly token?: string \| null;
		/**
		* Whether to use private github auto-update provider if `GH_TOKEN` environment variable is defined. See [Private GitHub Update Repo](https://www.electron.build/auto-update#private-github-update-repo).
		*/
		readonly private?: boolean \| null;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		/**
		* The type of release. By default `draft` release will be created.
		*
		* Also you can set release type using environment variable. If `EP_DRAFT`is set to `true` — `draft`, if `EP_PRE_RELEASE`is set to `true` — `prerelease`.
		* @default draft
		*/
		releaseType?: "draft" \| "prerelease" \| "release" \| null;
		}
		/** @private */
		export declare function githubUrl(options: GithubOptions, defaultHost?: string): string;
		export declare function githubTagPrefix(options: GithubOptions): string;
		/**
		* [GitLab](https://docs.gitlab.com/ee/user/project/releases/) options.
		*
		* GitLab [personal access token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) is required for private repositories. You can generate one by going to your GitLab profile settings.
		* Define `GITLAB_TOKEN` environment variable.
		*/
		export interface GitlabOptions extends PublishConfiguration {
		/**
		* The provider. Must be `gitlab`.
		*/
		readonly provider: "gitlab";
		/**
		* The GitLab project ID or path (e.g., "12345678" or "namespace/project").
		*/
		readonly projectId?: string \| number \| null;
		/**
		* The GitLab host (including the port if need).
		* @default gitlab.com
		*/
		readonly host?: string \| null;
		/**
		* The access token to support auto-update from private GitLab repositories. Never specify it in the configuration files.
		*/
		readonly token?: string \| null;
		/**
		* Whether to use `v`-prefixed tag name.
		* @default true
		*/
		readonly vPrefixedTagName?: boolean;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		/**
		* Upload target method. Can be "project_upload" for GitLab project uploads or "generic_package" for GitLab generic packages.
		* @default "project_upload"
		*/
		readonly uploadTarget?: "project_upload" \| "generic_package" \| null;
		}
		/**
		* Generic (any HTTP(S) server) options.
		* In all publish options [File Macros](https://www.electron.build/file-patterns#file-macros) are supported.
		*/
		export interface GenericServerOptions extends PublishConfiguration {
		/**
		* The provider. Must be `generic`.
		*/
		readonly provider: "generic";
		/**
		* The base url. e.g. `https://bucket_name.s3.amazonaws.com`.
		*/
		readonly url: string;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		/**
		* Whether to use multiple range requests for differential update. Defaults to `true` if `url` doesn't contain `s3.amazonaws.com`.
		*/
		readonly useMultipleRangeRequest?: boolean;
		}
		/**
		* Keygen options.
		* https://keygen.sh/
		* Define `KEYGEN_TOKEN` environment variable.
		*/
		export interface KeygenOptions extends PublishConfiguration {
		/**
		* The provider. Must be `keygen`.
		*/
		readonly provider: "keygen";
		/**
		* Keygen host for self-hosted instances
		* @default "api.keygen.sh"
		*/
		readonly host?: string;
		/**
		* Keygen account's UUID
		*/
		readonly account: string;
		/**
		* Keygen product's UUID
		*/
		readonly product: string;
		/**
		* The channel.
		* @default stable
		*/
		readonly channel?: "stable" \| "rc" \| "beta" \| "alpha" \| "dev" \| null;
		/**
		* The target Platform. Is set programmatically explicitly during publishing.
		*/
		readonly platform?: string \| null;
		}
		/**
		* Bitbucket options.
		* https://bitbucket.org/
		* Define `BITBUCKET_TOKEN` environment variable.
		*
		* For converting an app password to a usable token, you can utilize this
		```typescript
		convertAppPassword(owner: string, appPassword: string) {
		const base64encodedData = Buffer.from(`${owner}:${appPassword.trim()}`).toString("base64")
		return `Basic ${base64encodedData}`
		}
		```
		*/
		export interface BitbucketOptions extends PublishConfiguration {
		/**
		* The provider. Must be `bitbucket`.
		*/
		readonly provider: "bitbucket";
		/**
		* Repository owner
		*/
		readonly owner: string;
		/**
		* The [app password](https://bitbucket.org/account/settings/app-passwords) to support auto-update from private bitbucket repositories.
		*/
		readonly token?: string \| null;
		/**
		* The user name to support auto-update from private bitbucket repositories.
		*/
		readonly username?: string \| null;
		/**
		* Repository slug/name
		*/
		readonly slug: string;
		/**
		* The channel.
		* @default latest
		*/
		readonly channel?: string \| null;
		}
		/**
		* [Snap Store](https://snapcraft.io/) options. To publish directly to Snapcraft, see <a href="https://snapcraft.io/docs/snapcraft-authentication">Snapcraft authentication options</a> for local or CI/CD authentication options.
		*/
		export interface SnapStoreOptions extends PublishConfiguration {
		/**
		* The provider. Must be `snapStore`.
		*/
		readonly provider: "snapStore";
		/**
		* snapcraft repo name
		*/
		readonly repo?: string;
		/**
		* The list of channels the snap would be released.
		* @default ["edge"]
		*/
		readonly channels?: string \| Array<string> \| null;
		}
		export interface BaseS3Options extends PublishConfiguration {
		/**
		* The update channel.
		* @default latest
		*/
		channel?: string \| null;
		/**
		* The directory path.
		* @default /
		*/
		readonly path?: string \| null;
		/**
		* The ACL. Set to `null` to not [add](https://github.com/electron-userland/electron-builder/issues/1822).
		*
		* @default public-read
		*/
		readonly acl?: "private" \| "public-read" \| null;
		}
		/**
		* [Amazon S3](https://aws.amazon.com/s3/) options.
		* AWS credentials are required, please see [getting your credentials](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/getting-your-credentials.html).
		* To set credentials define `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` [environment variables](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-environment.html) directly,
		* or use [~/.aws/credentials](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-shared.html) file,
		* or use [~/.aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) file. For the last method to work you will also need to define `AWS_SDK_LOAD_CONFIG=1` environment variable.
		*
		* Example configuration:
		*
		```json
		{
		"build":
		"publish": {
		"provider": "s3",
		"bucket": "bucket-name"
		}
		}
		}
		```
		*/
		export interface S3Options extends BaseS3Options {
		/**
		* The provider. Must be `s3`.
		*/
		readonly provider: "s3";
		/**
		* The bucket name.
		*/
		readonly bucket: string;
		/**
		* The region. Is determined and set automatically when publishing.
		*/
		region?: string \| null;
		/**
		* The ACL. Set to `null` to not [add](https://github.com/electron-userland/electron-builder/issues/1822).
		*
		* Please see [required permissions for the S3 provider](https://github.com/electron-userland/electron-builder/issues/1618#issuecomment-314679128).
		*
		* @default public-read
		*/
		readonly acl?: "private" \| "public-read" \| null;
		/**
		* The type of storage to use for the object.
		* @default STANDARD
		*/
		readonly storageClass?: "STANDARD" \| "REDUCED_REDUNDANCY" \| "STANDARD_IA" \| null;
		/**
		* Server-side encryption algorithm to use for the object.
		*/
		readonly encryption?: "AES256" \| "aws:kms" \| null;
		/**
		* The endpoint URI to send requests to. The default endpoint is built from the configured region.
		* The endpoint should be a string like `https://{service}.{region}.amazonaws.com`.
		*/
		readonly endpoint?: string \| null;
		/**
		* If set to true, this will enable the s3 accelerated endpoint
		* These endpoints have a particular format of:
		* ${bucketname}.s3-accelerate.amazonaws.com
		*/
		readonly accelerate?: boolean;
		/**
		* When true, force a path-style endpoint to be used where the bucket name is part of the path.
		* [Path-style Access](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access)
		*/
		readonly forcePathStyle?: boolean;
		}
		/**
		* [DigitalOcean Spaces](https://www.digitalocean.com/community/tutorials/an-introduction-to-digitalocean-spaces) options.
		* Access key is required, define `DO_KEY_ID` and `DO_SECRET_KEY` environment variables.
		*/
		export interface SpacesOptions extends BaseS3Options {
		/**
		* The provider. Must be `spaces`.
		*/
		readonly provider: "spaces";
		/**
		* The space name.
		*/
		readonly name: string;
		/**
		* The region (e.g. `nyc3`).
		*/
		readonly region: string;
		}
		export interface GitlabReleaseInfo {
		name: string;
		tag_name: string;
		description: string;
		created_at: string;
		released_at: string;
		upcoming_release: boolean;
		assets: GitlabReleaseAsset;
		}
		export interface GitlabReleaseAsset {
		count: number;
		sources: Array<{
		format: string;
		url: string;
		}>;
		links: Array<{
		id: number;
		name: string;
		url: string;
		direct_asset_url: string;
		link_type: string;
		}>;
		}
		export declare function getS3LikeProviderBaseUrl(configuration: PublishConfiguration): string;

-76

out/publishOptions.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.githubUrl = githubUrl;
		exports.githubTagPrefix = githubTagPrefix;
		exports.getS3LikeProviderBaseUrl = getS3LikeProviderBaseUrl;
		/** @private */
		function githubUrl(options, defaultHost = "github.com") {
		return `${options.protocol \|\| "https"}://${options.host \|\| defaultHost}`;
		}
		function githubTagPrefix(options) {
		var _a;
		if (options.tagNamePrefix) {
		return options.tagNamePrefix;
		}
		if ((_a = options.vPrefixedTagName) !== null && _a !== void 0 ? _a : true) {
		return "v";
		}
		return "";
		}
		function getS3LikeProviderBaseUrl(configuration) {
		const provider = configuration.provider;
		if (provider === "s3") {
		return s3Url(configuration);
		}
		if (provider === "spaces") {
		return spacesUrl(configuration);
		}
		throw new Error(`Not supported provider: ${provider}`);
		}
		function s3Url(options) {
		let url;
		if (options.accelerate == true) {
		url = `https://${options.bucket}.s3-accelerate.amazonaws.com`;
		}
		else if (options.endpoint != null) {
		url = `${options.endpoint}/${options.bucket}`;
		}
		else if (options.bucket.includes(".")) {
		if (options.region == null) {
		throw new Error(`Bucket name "${options.bucket}" includes a dot, but S3 region is missing`);
		}
		// special case, see http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro
		if (options.region === "us-east-1") {
		url = `https://s3.amazonaws.com/${options.bucket}`;
		}
		else {
		url = `https://s3-${options.region}.amazonaws.com/${options.bucket}`;
		}
		}
		else if (options.region === "cn-north-1") {
		url = `https://${options.bucket}.s3.${options.region}.amazonaws.com.cn`;
		}
		else {
		url = `https://${options.bucket}.s3.amazonaws.com`;
		}
		return appendPath(url, options.path);
		}
		function appendPath(url, p) {
		if (p != null && p.length > 0) {
		if (!p.startsWith("/")) {
		url += "/";
		}
		url += p;
		}
		return url;
		}
		function spacesUrl(options) {
		if (options.name == null) {
		throw new Error(`name is missing`);
		}
		if (options.region == null) {
		throw new Error(`region is missing`);
		}
		return appendPath(`https://${options.name}.${options.region}.digitaloceanspaces.com`, options.path);
		}
		//# sourceMappingURL=publishOptions.js.map

-1

out/publishOptions.js.map

-9

out/retry.d.ts

		import { CancellationToken } from "./CancellationToken";
		export declare function retry<T>(task: () => Promise<T>, options: {
		retries: number;
		interval: number;
		backoff?: number;
		attempt?: number;
		cancellationToken?: CancellationToken;
		shouldRetry?: (e: any) => boolean \| Promise<boolean>;
		}): Promise<T>;

-21

out/retry.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.retry = retry;
		const CancellationToken_1 = require("./CancellationToken");
		async function retry(task, options) {
		var _a;
		const { retries: retryCount, interval, backoff = 0, attempt = 0, shouldRetry, cancellationToken = new CancellationToken_1.CancellationToken() } = options;
		try {
		return await task();
		}
		catch (error) {
		if ((await Promise.resolve((_a = shouldRetry === null \|\| shouldRetry === void 0 ? void 0 : shouldRetry(error)) !== null && _a !== void 0 ? _a : true)) && retryCount > 0 && !cancellationToken.cancelled) {
		await new Promise(resolve => setTimeout(resolve, interval + backoff * attempt));
		return await retry(task, { ...options, retries: retryCount - 1, attempt: attempt + 1 });
		}
		else {
		throw error;
		}
		}
		}
		//# sourceMappingURL=retry.js.map

-1

out/retry.js.map

{"version":3,"file":"retry.js","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":";;AAEA,sBAeC;AAjBD,2DAAuD;AAEhD,KAAK,UAAU,KAAK,CACzB,IAAsB,EACtB,OAA+K;;IAE/K,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,WAAW,EAAE,iBAAiB,GAAG,IAAI,qCAAiB,EAAE,EAAE,GAAG,OAAO,CAAA;IACrI,IAAI,CAAC;QACH,OAAO,MAAM,IAAI,EAAE,CAAA;IACrB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,IAAI,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,MAAA,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAG,KAAK,CAAC,mCAAI,IAAI,CAAC,CAAC,IAAI,UAAU,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YAC5G,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,CAAA;YAC/E,OAAO,MAAM,KAAK,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAA;QACzF,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import { CancellationToken } from \"./CancellationToken\"\n\nexport async function retry<T>(\n task: () => Promise<T>,\n options: { retries: number; interval: number; backoff?: number; attempt?: number; cancellationToken?: CancellationToken; shouldRetry?: (e: any) => boolean | Promise<boolean> }\n): Promise<T> {\n const { retries: retryCount, interval, backoff = 0, attempt = 0, shouldRetry, cancellationToken = new CancellationToken() } = options\n try {\n return await task()\n } catch (error: any) {\n if ((await Promise.resolve(shouldRetry?.(error) ?? true)) && retryCount > 0 && !cancellationToken.cancelled) {\n await new Promise(resolve => setTimeout(resolve, interval + backoff * attempt))\n return await retry(task, { ...options, retries: retryCount - 1, attempt: attempt + 1 })\n } else {\n throw error\n }\n }\n}\n"]}

-1

out/rfc2253Parser.d.ts

export declare function parseDn(seq: string): Map<string, string>;

-80

out/rfc2253Parser.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.parseDn = parseDn;
		function parseDn(seq) {
		let quoted = false;
		let key = null;
		let token = "";
		let nextNonSpace = 0;
		seq = seq.trim();
		const result = new Map();
		for (let i = 0; i <= seq.length; i++) {
		if (i === seq.length) {
		if (key !== null) {
		result.set(key, token);
		}
		break;
		}
		const ch = seq[i];
		if (quoted) {
		if (ch === '"') {
		quoted = false;
		continue;
		}
		}
		else {
		if (ch === '"') {
		quoted = true;
		continue;
		}
		if (ch === "\\") {
		i++;
		const ord = parseInt(seq.slice(i, i + 2), 16);
		if (Number.isNaN(ord)) {
		token += seq[i];
		}
		else {
		i++;
		token += String.fromCharCode(ord);
		}
		continue;
		}
		if (key === null && ch === "=") {
		key = token;
		token = "";
		continue;
		}
		if (ch === "," \|\| ch === ";" \|\| ch === "+") {
		if (key !== null) {
		result.set(key, token);
		}
		key = null;
		token = "";
		continue;
		}
		}
		if (ch === " " && !quoted) {
		if (token.length === 0) {
		continue;
		}
		if (i > nextNonSpace) {
		let j = i;
		while (seq[j] === " ") {
		j++;
		}
		nextNonSpace = j;
		}
		if (nextNonSpace >= seq.length \|\|
		seq[nextNonSpace] === "," \|\|
		seq[nextNonSpace] === ";" \|\|
		(key === null && seq[nextNonSpace] === "=") \|\|
		(key !== null && seq[nextNonSpace] === "+")) {
		i = nextNonSpace - 1;
		continue;
		}
		}
		token += ch;
		}
		return result;
		}
		//# sourceMappingURL=rfc2253Parser.js.map

-1

out/rfc2253Parser.js.map

{"version":3,"file":"rfc2253Parser.js","sourceRoot":"","sources":["../src/rfc2253Parser.ts"],"names":[],"mappings":"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","sourcesContent":["export function parseDn(seq: string): Map<string, string> {\n let quoted = false\n let key: string | null = null\n let token = \"\"\n let nextNonSpace = 0\n\n seq = seq.trim()\n const result = new Map<string, string>()\n for (let i = 0; i <= seq.length; i++) {\n if (i === seq.length) {\n if (key !== null) {\n result.set(key, token)\n }\n break\n }\n\n const ch = seq[i]\n if (quoted) {\n if (ch === '\"') {\n quoted = false\n continue\n }\n } else {\n if (ch === '\"') {\n quoted = true\n continue\n }\n\n if (ch === \"\\\\\") {\n i++\n const ord = parseInt(seq.slice(i, i + 2), 16)\n if (Number.isNaN(ord)) {\n token += seq[i]\n } else {\n i++\n token += String.fromCharCode(ord)\n }\n continue\n }\n\n if (key === null && ch === \"=\") {\n key = token\n token = \"\"\n continue\n }\n\n if (ch === \",\" || ch === \";\" || ch === \"+\") {\n if (key !== null) {\n result.set(key, token)\n }\n key = null\n token = \"\"\n continue\n }\n }\n\n if (ch === \" \" && !quoted) {\n if (token.length === 0) {\n continue\n }\n\n if (i > nextNonSpace) {\n let j = i\n while (seq[j] === \" \") {\n j++\n }\n nextNonSpace = j\n }\n\n if (\n nextNonSpace >= seq.length ||\n seq[nextNonSpace] === \",\" ||\n seq[nextNonSpace] === \";\" ||\n (key === null && seq[nextNonSpace] === \"=\") ||\n (key !== null && seq[nextNonSpace] === \"+\")\n ) {\n i = nextNonSpace - 1\n continue\n }\n }\n\n token += ch\n }\n\n return result\n}\n"]}

-76

out/updateInfo.d.ts

		export interface ReleaseNoteInfo {
		/**
		* The version.
		*/
		readonly version: string;
		/**
		* The note.
		*/
		readonly note: string \| null;
		}
		export interface BlockMapDataHolder {
		/**
		* The file size. Used to verify downloaded size (save one HTTP request to get length).
		* Also used when block map data is embedded into the file (appimage, windows web installer package).
		*/
		size?: number;
		/**
		* The block map file size. Used when block map data is embedded into the file (appimage, windows web installer package).
		* This information can be obtained from the file itself, but it requires additional HTTP request,
		* so, to reduce request count, block map size is specified in the update metadata too.
		*/
		blockMapSize?: number;
		/**
		* The file checksum.
		*/
		readonly sha512: string;
		readonly isAdminRightsRequired?: boolean;
		}
		export interface PackageFileInfo extends BlockMapDataHolder {
		readonly path: string;
		}
		export interface UpdateFileInfo extends BlockMapDataHolder {
		url: string;
		}
		export interface UpdateInfo {
		/**
		* The version.
		*/
		readonly version: string;
		readonly files: Array<UpdateFileInfo>;
		/** @deprecated */
		readonly path: string;
		/** @deprecated */
		readonly sha512: string;
		/**
		* The release name.
		*/
		releaseName?: string \| null;
		/**
		* The release notes. List if `updater.fullChangelog` is set to `true`, `string` otherwise.
		*/
		releaseNotes?: string \| Array<ReleaseNoteInfo> \| null;
		/**
		* The release date.
		*/
		releaseDate: string;
		/**
		* The [staged rollout](https://www.electron.build/auto-update#staged-rollouts) percentage, 0-100.
		*/
		readonly stagingPercentage?: number;
		/**
		* The minimum version of system required for the app to run. Sample value: macOS `23.1.0`, Windows `10.0.22631`.
		* Same with os.release() value, this is a kernel version.
		*/
		readonly minimumSystemVersion?: string;
		}
		export interface WindowsUpdateInfo extends UpdateInfo {
		packages?: {
		[arch: string]: PackageFileInfo;
		} \| null;
		/**
		* @deprecated
		* @private
		*/
		sha2?: string;
		}

-3

out/updateInfo.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		//# sourceMappingURL=updateInfo.js.map

-1

out/updateInfo.js.map

{"version":3,"file":"updateInfo.js","sourceRoot":"","sources":["../src/updateInfo.ts"],"names":[],"mappings":"","sourcesContent":["export interface ReleaseNoteInfo {\n /**\n * The version.\n */\n readonly version: string\n\n /**\n * The note.\n */\n readonly note: string | null\n}\n\nexport interface BlockMapDataHolder {\n /**\n * The file size. Used to verify downloaded size (save one HTTP request to get length).\n * Also used when block map data is embedded into the file (appimage, windows web installer package).\n */\n size?: number\n\n /**\n * The block map file size. Used when block map data is embedded into the file (appimage, windows web installer package).\n * This information can be obtained from the file itself, but it requires additional HTTP request,\n * so, to reduce request count, block map size is specified in the update metadata too.\n */\n blockMapSize?: number\n\n /**\n * The file checksum.\n */\n readonly sha512: string\n\n readonly isAdminRightsRequired?: boolean\n}\n\nexport interface PackageFileInfo extends BlockMapDataHolder {\n readonly path: string\n}\n\nexport interface UpdateFileInfo extends BlockMapDataHolder {\n url: string\n}\n\nexport interface UpdateInfo {\n /**\n * The version.\n */\n readonly version: string\n\n readonly files: Array<UpdateFileInfo>\n\n /** @deprecated */\n readonly path: string\n\n /** @deprecated */\n readonly sha512: string\n\n /**\n * The release name.\n */\n releaseName?: string | null\n\n /**\n * The release notes. List if `updater.fullChangelog` is set to `true`, `string` otherwise.\n */\n releaseNotes?: string | Array<ReleaseNoteInfo> | null\n\n /**\n * The release date.\n */\n releaseDate: string\n\n /**\n * The [staged rollout](https://www.electron.build/auto-update#staged-rollouts) percentage, 0-100.\n */\n readonly stagingPercentage?: number\n\n /**\n * The minimum version of system required for the app to run. Sample value: macOS `23.1.0`, Windows `10.0.22631`.\n * Same with os.release() value, this is a kernel version.\n */\n readonly minimumSystemVersion?: string\n}\n\nexport interface WindowsUpdateInfo extends UpdateInfo {\n packages?: { [arch: string]: PackageFileInfo } | null\n\n /**\n * @deprecated\n * @private\n */\n sha2?: string\n}\n"]}

-21

out/uuid.d.ts

		export declare class UUID {
		private ascii;
		private readonly binary;
		private readonly version;
		static readonly OID: Buffer;
		constructor(uuid: Buffer \| string);
		static v5(name: string \| Buffer, namespace: Buffer): any;
		toString(): string;
		inspect(): string;
		static check(uuid: Buffer \| string, offset?: number): false \| {
		version: undefined;
		variant: string;
		format: string;
		} \| {
		version: number;
		variant: string;
		format: string;
		};
		static parse(input: string): Buffer;
		}
		export declare const nil: UUID;

-200

out/uuid.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.nil = exports.UUID = void 0;
		const crypto_1 = require("crypto");
		const error_1 = require("./error");
		const invalidName = "options.name must be either a string or a Buffer";
		// Node ID according to rfc4122#section-4.5
		const randomHost = (0, crypto_1.randomBytes)(16);
		randomHost[0] = randomHost[0] \| 0x01;
		// lookup table hex to byte
		const hex2byte = {};
		// lookup table byte to hex
		const byte2hex = [];
		// populate lookup tables
		for (let i = 0; i < 256; i++) {
		const hex = (i + 0x100).toString(16).substr(1);
		hex2byte[hex] = i;
		byte2hex[i] = hex;
		}
		// UUID class
		class UUID {
		constructor(uuid) {
		this.ascii = null;
		this.binary = null;
		const check = UUID.check(uuid);
		if (!check) {
		throw new Error("not a UUID");
		}
		this.version = check.version;
		if (check.format === "ascii") {
		this.ascii = uuid;
		}
		else {
		this.binary = uuid;
		}
		}
		static v5(name, namespace) {
		return uuidNamed(name, "sha1", 0x50, namespace);
		}
		toString() {
		if (this.ascii == null) {
		this.ascii = stringify(this.binary);
		}
		return this.ascii;
		}
		inspect() {
		return `UUID v${this.version} ${this.toString()}`;
		}
		static check(uuid, offset = 0) {
		if (typeof uuid === "string") {
		uuid = uuid.toLowerCase();
		if (!/^[a-f0-9]{8}(-[a-f0-9]{4}){3}-([a-f0-9]{12})$/.test(uuid)) {
		return false;
		}
		if (uuid === "00000000-0000-0000-0000-000000000000") {
		return { version: undefined, variant: "nil", format: "ascii" };
		}
		return {
		version: (hex2byte[uuid[14] + uuid[15]] & 0xf0) >> 4,
		variant: getVariant((hex2byte[uuid[19] + uuid[20]] & 0xe0) >> 5),
		format: "ascii",
		};
		}
		if (Buffer.isBuffer(uuid)) {
		if (uuid.length < offset + 16) {
		return false;
		}
		let i = 0;
		for (; i < 16; i++) {
		if (uuid[offset + i] !== 0) {
		break;
		}
		}
		if (i === 16) {
		return { version: undefined, variant: "nil", format: "binary" };
		}
		return {
		version: (uuid[offset + 6] & 0xf0) >> 4,
		variant: getVariant((uuid[offset + 8] & 0xe0) >> 5),
		format: "binary",
		};
		}
		throw (0, error_1.newError)("Unknown type of uuid", "ERR_UNKNOWN_UUID_TYPE");
		}
		// read stringified uuid into a Buffer
		static parse(input) {
		const buffer = Buffer.allocUnsafe(16);
		let j = 0;
		for (let i = 0; i < 16; i++) {
		buffer[i] = hex2byte[input[j++] + input[j++]];
		if (i === 3 \|\| i === 5 \|\| i === 7 \|\| i === 9) {
		j += 1;
		}
		}
		return buffer;
		}
		}
		exports.UUID = UUID;
		// from rfc4122#appendix-C
		UUID.OID = UUID.parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8");
		// according to rfc4122#section-4.1.1
		function getVariant(bits) {
		switch (bits) {
		case 0:
		case 1:
		case 3:
		return "ncs";
		case 4:
		case 5:
		return "rfc4122";
		case 6:
		return "microsoft";
		default:
		return "future";
		}
		}
		var UuidEncoding;
		(function (UuidEncoding) {
		UuidEncoding[UuidEncoding["ASCII"] = 0] = "ASCII";
		UuidEncoding[UuidEncoding["BINARY"] = 1] = "BINARY";
		UuidEncoding[UuidEncoding["OBJECT"] = 2] = "OBJECT";
		})(UuidEncoding \|\| (UuidEncoding = {}));
		// v3 + v5
		function uuidNamed(name, hashMethod, version, namespace, encoding = UuidEncoding.ASCII) {
		const hash = (0, crypto_1.createHash)(hashMethod);
		const nameIsNotAString = typeof name !== "string";
		if (nameIsNotAString && !Buffer.isBuffer(name)) {
		throw (0, error_1.newError)(invalidName, "ERR_INVALID_UUID_NAME");
		}
		hash.update(namespace);
		hash.update(name);
		const buffer = hash.digest();
		let result;
		switch (encoding) {
		case UuidEncoding.BINARY:
		buffer[6] = (buffer[6] & 0x0f) \| version;
		buffer[8] = (buffer[8] & 0x3f) \| 0x80;
		result = buffer;
		break;
		case UuidEncoding.OBJECT:
		buffer[6] = (buffer[6] & 0x0f) \| version;
		buffer[8] = (buffer[8] & 0x3f) \| 0x80;
		result = new UUID(buffer);
		break;
		default:
		result =
		byte2hex[buffer[0]] +
		byte2hex[buffer[1]] +
		byte2hex[buffer[2]] +
		byte2hex[buffer[3]] +
		"-" +
		byte2hex[buffer[4]] +
		byte2hex[buffer[5]] +
		"-" +
		byte2hex[(buffer[6] & 0x0f) \| version] +
		byte2hex[buffer[7]] +
		"-" +
		byte2hex[(buffer[8] & 0x3f) \| 0x80] +
		byte2hex[buffer[9]] +
		"-" +
		byte2hex[buffer[10]] +
		byte2hex[buffer[11]] +
		byte2hex[buffer[12]] +
		byte2hex[buffer[13]] +
		byte2hex[buffer[14]] +
		byte2hex[buffer[15]];
		break;
		}
		return result;
		}
		function stringify(buffer) {
		return (byte2hex[buffer[0]] +
		byte2hex[buffer[1]] +
		byte2hex[buffer[2]] +
		byte2hex[buffer[3]] +
		"-" +
		byte2hex[buffer[4]] +
		byte2hex[buffer[5]] +
		"-" +
		byte2hex[buffer[6]] +
		byte2hex[buffer[7]] +
		"-" +
		byte2hex[buffer[8]] +
		byte2hex[buffer[9]] +
		"-" +
		byte2hex[buffer[10]] +
		byte2hex[buffer[11]] +
		byte2hex[buffer[12]] +
		byte2hex[buffer[13]] +
		byte2hex[buffer[14]] +
		byte2hex[buffer[15]]);
		}
		// according to rfc4122#section-4.1.7
		exports.nil = new UUID("00000000-0000-0000-0000-000000000000");
		// UUID.v4 = uuidRandom
		// UUID.v4fast = uuidRandomFast
		// UUID.v3 = function(options, callback) {
		// return uuidNamed("md5", 0x30, options, callback)
		// }
		//# sourceMappingURL=uuid.js.map

-1

out/uuid.js.map

-15

out/xml.d.ts

		export declare class XElement {
		readonly name: string;
		value: string;
		attributes: Record<string, string> \| null;
		isCData: boolean;
		elements: Array<XElement> \| null;
		constructor(name: string);
		attribute(name: string): string;
		removeAttribute(name: string): void;
		element(name: string, ignoreCase?: boolean, errorIfMissed?: string \| null): XElement;
		elementOrNull(name: string, ignoreCase?: boolean): XElement \| null;
		getElements(name: string, ignoreCase?: boolean): XElement[];
		elementValueOrEmpty(name: string, ignoreCase?: boolean): string;
		}
		export declare function parseXml(data: string): XElement;

-109

out/xml.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.XElement = void 0;
		exports.parseXml = parseXml;
		const sax = require("sax");
		const error_1 = require("./error");
		class XElement {
		constructor(name) {
		this.name = name;
		this.value = "";
		this.attributes = null;
		this.isCData = false;
		this.elements = null;
		if (!name) {
		throw (0, error_1.newError)("Element name cannot be empty", "ERR_XML_ELEMENT_NAME_EMPTY");
		}
		if (!isValidName(name)) {
		throw (0, error_1.newError)(`Invalid element name: ${name}`, "ERR_XML_ELEMENT_INVALID_NAME");
		}
		}
		attribute(name) {
		const result = this.attributes === null ? null : this.attributes[name];
		if (result == null) {
		throw (0, error_1.newError)(`No attribute "${name}"`, "ERR_XML_MISSED_ATTRIBUTE");
		}
		return result;
		}
		removeAttribute(name) {
		if (this.attributes !== null) {
		delete this.attributes[name];
		}
		}
		element(name, ignoreCase = false, errorIfMissed = null) {
		const result = this.elementOrNull(name, ignoreCase);
		if (result === null) {
		throw (0, error_1.newError)(errorIfMissed \|\| `No element "${name}"`, "ERR_XML_MISSED_ELEMENT");
		}
		return result;
		}
		elementOrNull(name, ignoreCase = false) {
		if (this.elements === null) {
		return null;
		}
		for (const element of this.elements) {
		if (isNameEquals(element, name, ignoreCase)) {
		return element;
		}
		}
		return null;
		}
		getElements(name, ignoreCase = false) {
		if (this.elements === null) {
		return [];
		}
		return this.elements.filter(it => isNameEquals(it, name, ignoreCase));
		}
		elementValueOrEmpty(name, ignoreCase = false) {
		const element = this.elementOrNull(name, ignoreCase);
		return element === null ? "" : element.value;
		}
		}
		exports.XElement = XElement;
		const NAME_REG_EXP = new RegExp(/^[A-Za-z_][:A-Za-z0-9_-]*$/i);
		function isValidName(name) {
		return NAME_REG_EXP.test(name);
		}
		function isNameEquals(element, name, ignoreCase) {
		const elementName = element.name;
		return elementName === name \|\| (ignoreCase === true && elementName.length === name.length && elementName.toLowerCase() === name.toLowerCase());
		}
		function parseXml(data) {
		let rootElement = null;
		const parser = sax.parser(true, {});
		const elements = [];
		parser.onopentag = saxElement => {
		const element = new XElement(saxElement.name);
		element.attributes = saxElement.attributes;
		if (rootElement === null) {
		rootElement = element;
		}
		else {
		const parent = elements[elements.length - 1];
		if (parent.elements == null) {
		parent.elements = [];
		}
		parent.elements.push(element);
		}
		elements.push(element);
		};
		parser.onclosetag = () => {
		elements.pop();
		};
		parser.ontext = text => {
		if (elements.length > 0) {
		elements[elements.length - 1].value = text;
		}
		};
		parser.oncdata = cdata => {
		const element = elements[elements.length - 1];
		element.value = cdata;
		element.isCData = true;
		};
		parser.onerror = err => {
		throw err;
		};
		parser.write(data);
		return rootElement;
		}
		//# sourceMappingURL=xml.js.map

-1

out/xml.js.map

builder-util-runtime - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics