mirror of
https://github.com/astral-sh/setup-uv.git
synced 2026-11-05 01:35:32 +00:00
chore(deps): roll up Dependabot updates (#1013)
## Summary Roll up the remaining dependency changes from: - #1008 (`@actions/glob` 0.7.0) - #1009 (`@types/node` 26.1.2) - #1010 (`js-yaml` 5.2.3) - #1011 (`@biomejs/biome` 2.5.7) - #1012 (`@types/semver` 7.8.0) The Biome schema URL and committed action bundles are updated accordingly. ## Validation - `npm run all` Refs: pi-session 019ff5b2-b439-7431-9595-b965f7fe6119
This commit is contained in:
Kevin Stillhammer
+2333
-454
@@ -1073,14 +1073,14 @@ var require_util = __commonJS({
|
||||
}
|
||||
const port = url2.port != null ? url2.port : url2.protocol === "https:" ? 443 : 80;
|
||||
let origin = url2.origin != null ? url2.origin : `${url2.protocol || ""}//${url2.hostname || ""}:${port}`;
|
||||
let path12 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
|
||||
let path13 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
|
||||
if (origin[origin.length - 1] === "/") {
|
||||
origin = origin.slice(0, origin.length - 1);
|
||||
}
|
||||
if (path12 && path12[0] !== "/") {
|
||||
path12 = `/${path12}`;
|
||||
if (path13 && path13[0] !== "/") {
|
||||
path13 = `/${path13}`;
|
||||
}
|
||||
return new URL(`${origin}${path12}`);
|
||||
return new URL(`${origin}${path13}`);
|
||||
}
|
||||
if (!isHttpOrHttpsPrefixed(url2.origin || url2.protocol)) {
|
||||
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
|
||||
@@ -1361,9 +1361,9 @@ var require_util = __commonJS({
|
||||
function isValidHeaderValue(characters) {
|
||||
return !headerCharRegex.test(characters);
|
||||
}
|
||||
function parseRangeHeader(range2) {
|
||||
if (range2 == null || range2 === "") return { start: 0, end: null, size: null };
|
||||
const m = range2 ? range2.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
|
||||
function parseRangeHeader(range3) {
|
||||
if (range3 == null || range3 === "") return { start: 0, end: null, size: null };
|
||||
const m = range3 ? range3.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
|
||||
return m ? {
|
||||
start: parseInt(m[1]),
|
||||
end: m[2] ? parseInt(m[2]) : null,
|
||||
@@ -1531,39 +1531,39 @@ var require_diagnostics = __commonJS({
|
||||
});
|
||||
diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
|
||||
const {
|
||||
request: { method, path: path12, origin }
|
||||
request: { method, path: path13, origin }
|
||||
} = evt;
|
||||
debuglog("sending request to %s %s/%s", method, origin, path12);
|
||||
debuglog("sending request to %s %s/%s", method, origin, path13);
|
||||
});
|
||||
diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => {
|
||||
const {
|
||||
request: { method, path: path12, origin },
|
||||
request: { method, path: path13, origin },
|
||||
response: { statusCode }
|
||||
} = evt;
|
||||
debuglog(
|
||||
"received response to %s %s/%s - HTTP %d",
|
||||
method,
|
||||
origin,
|
||||
path12,
|
||||
path13,
|
||||
statusCode
|
||||
);
|
||||
});
|
||||
diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => {
|
||||
const {
|
||||
request: { method, path: path12, origin }
|
||||
request: { method, path: path13, origin }
|
||||
} = evt;
|
||||
debuglog("trailers received from %s %s/%s", method, origin, path12);
|
||||
debuglog("trailers received from %s %s/%s", method, origin, path13);
|
||||
});
|
||||
diagnosticsChannel.channel("undici:request:error").subscribe((evt) => {
|
||||
const {
|
||||
request: { method, path: path12, origin },
|
||||
request: { method, path: path13, origin },
|
||||
error: error2
|
||||
} = evt;
|
||||
debuglog(
|
||||
"request to %s %s/%s errored - %s",
|
||||
method,
|
||||
origin,
|
||||
path12,
|
||||
path13,
|
||||
error2.message
|
||||
);
|
||||
});
|
||||
@@ -1612,9 +1612,9 @@ var require_diagnostics = __commonJS({
|
||||
});
|
||||
diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
|
||||
const {
|
||||
request: { method, path: path12, origin }
|
||||
request: { method, path: path13, origin }
|
||||
} = evt;
|
||||
debuglog("sending request to %s %s/%s", method, origin, path12);
|
||||
debuglog("sending request to %s %s/%s", method, origin, path13);
|
||||
});
|
||||
}
|
||||
diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => {
|
||||
@@ -1677,7 +1677,7 @@ var require_request = __commonJS({
|
||||
var kHandler = /* @__PURE__ */ Symbol("handler");
|
||||
var Request = class {
|
||||
constructor(origin, {
|
||||
path: path12,
|
||||
path: path13,
|
||||
method,
|
||||
body: body2,
|
||||
headers,
|
||||
@@ -1692,11 +1692,11 @@ var require_request = __commonJS({
|
||||
expectContinue,
|
||||
servername
|
||||
}, handler) {
|
||||
if (typeof path12 !== "string") {
|
||||
if (typeof path13 !== "string") {
|
||||
throw new InvalidArgumentError("path must be a string");
|
||||
} else if (path12[0] !== "/" && !(path12.startsWith("http://") || path12.startsWith("https://")) && method !== "CONNECT") {
|
||||
} else if (path13[0] !== "/" && !(path13.startsWith("http://") || path13.startsWith("https://")) && method !== "CONNECT") {
|
||||
throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
|
||||
} else if (invalidPathRegex.test(path12)) {
|
||||
} else if (invalidPathRegex.test(path13)) {
|
||||
throw new InvalidArgumentError("invalid request path");
|
||||
}
|
||||
if (typeof method !== "string") {
|
||||
@@ -1762,7 +1762,7 @@ var require_request = __commonJS({
|
||||
this.completed = false;
|
||||
this.aborted = false;
|
||||
this.upgrade = upgrade || null;
|
||||
this.path = query ? buildURL(path12, query) : path12;
|
||||
this.path = query ? buildURL(path13, query) : path13;
|
||||
this.origin = origin;
|
||||
this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
|
||||
this.blocking = blocking == null ? false : blocking;
|
||||
@@ -3577,7 +3577,7 @@ var require_data_url = __commonJS({
|
||||
var require_webidl = __commonJS({
|
||||
"node_modules/@actions/http-client/node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var { types, inspect: inspect2 } = require("node:util");
|
||||
var { types: types2, inspect: inspect2 } = require("node:util");
|
||||
var { markAsUncloneable } = require("node:worker_threads");
|
||||
var { toUSVString } = require_util();
|
||||
var webidl = {};
|
||||
@@ -3767,7 +3767,7 @@ var require_webidl = __commonJS({
|
||||
});
|
||||
}
|
||||
const result = {};
|
||||
if (!types.isProxy(O)) {
|
||||
if (!types2.isProxy(O)) {
|
||||
const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
|
||||
for (const key of keys2) {
|
||||
const typedKey = keyConverter(key, prefix2, argument);
|
||||
@@ -3896,14 +3896,14 @@ var require_webidl = __commonJS({
|
||||
return x;
|
||||
};
|
||||
webidl.converters.ArrayBuffer = function(V, prefix2, argument, opts) {
|
||||
if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) {
|
||||
if (webidl.util.Type(V) !== "Object" || !types2.isAnyArrayBuffer(V)) {
|
||||
throw webidl.errors.conversionFailed({
|
||||
prefix: prefix2,
|
||||
argument: `${argument} ("${webidl.util.Stringify(V)}")`,
|
||||
types: ["ArrayBuffer"]
|
||||
});
|
||||
}
|
||||
if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
|
||||
if (opts?.allowShared === false && types2.isSharedArrayBuffer(V)) {
|
||||
throw webidl.errors.exception({
|
||||
header: "ArrayBuffer",
|
||||
message: "SharedArrayBuffer is not allowed."
|
||||
@@ -3918,14 +3918,14 @@ var require_webidl = __commonJS({
|
||||
return V;
|
||||
};
|
||||
webidl.converters.TypedArray = function(V, T, prefix2, name, opts) {
|
||||
if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) {
|
||||
if (webidl.util.Type(V) !== "Object" || !types2.isTypedArray(V) || V.constructor.name !== T.name) {
|
||||
throw webidl.errors.conversionFailed({
|
||||
prefix: prefix2,
|
||||
argument: `${name} ("${webidl.util.Stringify(V)}")`,
|
||||
types: [T.name]
|
||||
});
|
||||
}
|
||||
if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
|
||||
if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
|
||||
throw webidl.errors.exception({
|
||||
header: "ArrayBuffer",
|
||||
message: "SharedArrayBuffer is not allowed."
|
||||
@@ -3940,13 +3940,13 @@ var require_webidl = __commonJS({
|
||||
return V;
|
||||
};
|
||||
webidl.converters.DataView = function(V, prefix2, name, opts) {
|
||||
if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) {
|
||||
if (webidl.util.Type(V) !== "Object" || !types2.isDataView(V)) {
|
||||
throw webidl.errors.exception({
|
||||
header: prefix2,
|
||||
message: `${name} is not a DataView.`
|
||||
});
|
||||
}
|
||||
if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
|
||||
if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
|
||||
throw webidl.errors.exception({
|
||||
header: "ArrayBuffer",
|
||||
message: "SharedArrayBuffer is not allowed."
|
||||
@@ -3961,13 +3961,13 @@ var require_webidl = __commonJS({
|
||||
return V;
|
||||
};
|
||||
webidl.converters.BufferSource = function(V, prefix2, name, opts) {
|
||||
if (types.isAnyArrayBuffer(V)) {
|
||||
if (types2.isAnyArrayBuffer(V)) {
|
||||
return webidl.converters.ArrayBuffer(V, prefix2, name, { ...opts, allowShared: false });
|
||||
}
|
||||
if (types.isTypedArray(V)) {
|
||||
if (types2.isTypedArray(V)) {
|
||||
return webidl.converters.TypedArray(V, V.constructor, prefix2, name, { ...opts, allowShared: false });
|
||||
}
|
||||
if (types.isDataView(V)) {
|
||||
if (types2.isDataView(V)) {
|
||||
return webidl.converters.DataView(V, prefix2, name, { ...opts, allowShared: false });
|
||||
}
|
||||
throw webidl.errors.conversionFailed({
|
||||
@@ -5420,7 +5420,7 @@ var require_body = __commonJS({
|
||||
const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
|
||||
const prefix2 = `--${boundary}\r
|
||||
Content-Disposition: form-data`;
|
||||
const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
|
||||
const escape3 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
|
||||
const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
|
||||
const blobParts = [];
|
||||
const rn = new Uint8Array([13, 10]);
|
||||
@@ -5428,14 +5428,14 @@ Content-Disposition: form-data`;
|
||||
let hasUnknownSizeValue = false;
|
||||
for (const [name, value] of object) {
|
||||
if (typeof value === "string") {
|
||||
const chunk2 = textEncoder.encode(prefix2 + `; name="${escape2(normalizeLinefeeds(name))}"\r
|
||||
const chunk2 = textEncoder.encode(prefix2 + `; name="${escape3(normalizeLinefeeds(name))}"\r
|
||||
\r
|
||||
${normalizeLinefeeds(value)}\r
|
||||
`);
|
||||
blobParts.push(chunk2);
|
||||
length += chunk2.byteLength;
|
||||
} else {
|
||||
const chunk2 = textEncoder.encode(`${prefix2}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r
|
||||
const chunk2 = textEncoder.encode(`${prefix2}; name="${escape3(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape3(value.name)}"` : "") + `\r
|
||||
Content-Type: ${value.type || "application/octet-stream"}\r
|
||||
\r
|
||||
`);
|
||||
@@ -6281,7 +6281,7 @@ var require_client_h1 = __commonJS({
|
||||
return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
|
||||
}
|
||||
function writeH1(client, request) {
|
||||
const { method, path: path12, host, upgrade, blocking, reset } = request;
|
||||
const { method, path: path13, host, upgrade, blocking, reset } = request;
|
||||
let { body: body2, headers, contentLength: contentLength2 } = request;
|
||||
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
|
||||
if (util4.isFormDataLike(body2)) {
|
||||
@@ -6347,7 +6347,7 @@ var require_client_h1 = __commonJS({
|
||||
if (blocking) {
|
||||
socket[kBlocking] = true;
|
||||
}
|
||||
let header = `${method} ${path12} HTTP/1.1\r
|
||||
let header = `${method} ${path13} HTTP/1.1\r
|
||||
`;
|
||||
if (typeof host === "string") {
|
||||
header += `host: ${host}\r
|
||||
@@ -6873,7 +6873,7 @@ var require_client_h2 = __commonJS({
|
||||
}
|
||||
function writeH2(client, request) {
|
||||
const session = client[kHTTP2Session];
|
||||
const { method, path: path12, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
|
||||
const { method, path: path13, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
|
||||
let { body: body2 } = request;
|
||||
if (upgrade) {
|
||||
util4.errorRequest(client, request, new Error("Upgrade not supported for H2"));
|
||||
@@ -6940,7 +6940,7 @@ var require_client_h2 = __commonJS({
|
||||
});
|
||||
return true;
|
||||
}
|
||||
headers[HTTP2_HEADER_PATH] = path12;
|
||||
headers[HTTP2_HEADER_PATH] = path13;
|
||||
headers[HTTP2_HEADER_SCHEME] = "https";
|
||||
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
|
||||
if (body2 && typeof body2.read === "function") {
|
||||
@@ -7293,9 +7293,9 @@ var require_redirect_handler = __commonJS({
|
||||
return this.handler.onHeaders(statusCode, headers, resume, statusText);
|
||||
}
|
||||
const { origin, pathname, search } = util4.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
|
||||
const path12 = search ? `${pathname}${search}` : pathname;
|
||||
const path13 = search ? `${pathname}${search}` : pathname;
|
||||
this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
|
||||
this.opts.path = path12;
|
||||
this.opts.path = path13;
|
||||
this.opts.origin = origin;
|
||||
this.opts.maxRedirections = 0;
|
||||
this.opts.query = null;
|
||||
@@ -8529,10 +8529,10 @@ var require_proxy_agent = __commonJS({
|
||||
};
|
||||
const {
|
||||
origin,
|
||||
path: path12 = "/",
|
||||
path: path13 = "/",
|
||||
headers = {}
|
||||
} = opts;
|
||||
opts.path = origin + path12;
|
||||
opts.path = origin + path13;
|
||||
if (!("host" in headers) && !("Host" in headers)) {
|
||||
const { host } = new URL2(origin);
|
||||
headers.host = host;
|
||||
@@ -9025,8 +9025,8 @@ var require_retry_handler = __commonJS({
|
||||
}
|
||||
if (this.end == null) {
|
||||
if (statusCode === 206) {
|
||||
const range2 = parseRangeHeader(headers["content-range"]);
|
||||
if (range2 == null) {
|
||||
const range3 = parseRangeHeader(headers["content-range"]);
|
||||
if (range3 == null) {
|
||||
return this.handler.onHeaders(
|
||||
statusCode,
|
||||
rawHeaders,
|
||||
@@ -9034,7 +9034,7 @@ var require_retry_handler = __commonJS({
|
||||
statusMessage
|
||||
);
|
||||
}
|
||||
const { start, size, end = size - 1 } = range2;
|
||||
const { start, size, end = size - 1 } = range3;
|
||||
assert4(
|
||||
start != null && Number.isFinite(start),
|
||||
"content-range mismatch"
|
||||
@@ -10391,15 +10391,15 @@ var require_mock_utils = __commonJS({
|
||||
isPromise
|
||||
}
|
||||
} = require("node:util");
|
||||
function matchValue(match2, value) {
|
||||
if (typeof match2 === "string") {
|
||||
return match2 === value;
|
||||
function matchValue(match4, value) {
|
||||
if (typeof match4 === "string") {
|
||||
return match4 === value;
|
||||
}
|
||||
if (match2 instanceof RegExp) {
|
||||
return match2.test(value);
|
||||
if (match4 instanceof RegExp) {
|
||||
return match4.test(value);
|
||||
}
|
||||
if (typeof match2 === "function") {
|
||||
return match2(value) === true;
|
||||
if (typeof match4 === "function") {
|
||||
return match4(value) === true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -10453,20 +10453,20 @@ var require_mock_utils = __commonJS({
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function safeUrl(path12) {
|
||||
if (typeof path12 !== "string") {
|
||||
return path12;
|
||||
function safeUrl(path13) {
|
||||
if (typeof path13 !== "string") {
|
||||
return path13;
|
||||
}
|
||||
const pathSegments = path12.split("?");
|
||||
const pathSegments = path13.split("?");
|
||||
if (pathSegments.length !== 2) {
|
||||
return path12;
|
||||
return path13;
|
||||
}
|
||||
const qp = new URLSearchParams(pathSegments.pop());
|
||||
qp.sort();
|
||||
return [...pathSegments, qp.toString()].join("?");
|
||||
}
|
||||
function matchKey(mockDispatch2, { path: path12, method, body: body2, headers }) {
|
||||
const pathMatch = matchValue(mockDispatch2.path, path12);
|
||||
function matchKey(mockDispatch2, { path: path13, method, body: body2, headers }) {
|
||||
const pathMatch = matchValue(mockDispatch2.path, path13);
|
||||
const methodMatch = matchValue(mockDispatch2.method, method);
|
||||
const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body2) : true;
|
||||
const headersMatch = matchHeaders(mockDispatch2, headers);
|
||||
@@ -10488,7 +10488,7 @@ var require_mock_utils = __commonJS({
|
||||
function getMockDispatch(mockDispatches, key) {
|
||||
const basePath = key.query ? buildURL(key.path, key.query) : key.path;
|
||||
const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
|
||||
let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path12 }) => matchValue(safeUrl(path12), resolvedPath));
|
||||
let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path13 }) => matchValue(safeUrl(path13), resolvedPath));
|
||||
if (matchedMockDispatches.length === 0) {
|
||||
throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
|
||||
}
|
||||
@@ -10526,9 +10526,9 @@ var require_mock_utils = __commonJS({
|
||||
}
|
||||
}
|
||||
function buildKey(opts) {
|
||||
const { path: path12, method, body: body2, headers, query } = opts;
|
||||
const { path: path13, method, body: body2, headers, query } = opts;
|
||||
return {
|
||||
path: path12,
|
||||
path: path13,
|
||||
method,
|
||||
body: body2,
|
||||
headers,
|
||||
@@ -10991,10 +10991,10 @@ var require_pending_interceptors_formatter = __commonJS({
|
||||
}
|
||||
format(pendingInterceptors) {
|
||||
const withPrettyHeaders = pendingInterceptors.map(
|
||||
({ method, path: path12, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
|
||||
({ method, path: path13, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
|
||||
Method: method,
|
||||
Origin: origin,
|
||||
Path: path12,
|
||||
Path: path13,
|
||||
"Status code": statusCode,
|
||||
Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
|
||||
Invocations: timesInvoked,
|
||||
@@ -12119,7 +12119,7 @@ var require_response = __commonJS({
|
||||
var { URLSerializer } = require_data_url();
|
||||
var { kConstruct } = require_symbols();
|
||||
var assert4 = require("node:assert");
|
||||
var { types } = require("node:util");
|
||||
var { types: types2 } = require("node:util");
|
||||
var textEncoder = new TextEncoder("utf-8");
|
||||
var Response = class _Response {
|
||||
// Creates network error Response.
|
||||
@@ -12440,7 +12440,7 @@ var require_response = __commonJS({
|
||||
if (isBlobLike(V)) {
|
||||
return webidl.converters.Blob(V, prefix2, name, { strict: false });
|
||||
}
|
||||
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
|
||||
if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
|
||||
return webidl.converters.BufferSource(V, prefix2, name);
|
||||
}
|
||||
if (util4.isFormDataLike(V)) {
|
||||
@@ -14676,7 +14676,7 @@ var require_util4 = __commonJS({
|
||||
var { ProgressEvent } = require_progressevent();
|
||||
var { getEncoding } = require_encoding();
|
||||
var { serializeAMimeType, parseMIMEType } = require_data_url();
|
||||
var { types } = require("node:util");
|
||||
var { types: types2 } = require("node:util");
|
||||
var { StringDecoder } = require("string_decoder");
|
||||
var { btoa: btoa2 } = require("node:buffer");
|
||||
var staticPropertyDescriptors = {
|
||||
@@ -14706,7 +14706,7 @@ var require_util4 = __commonJS({
|
||||
});
|
||||
}
|
||||
isFirstChunk = false;
|
||||
if (!done && types.isUint8Array(value)) {
|
||||
if (!done && types2.isUint8Array(value)) {
|
||||
bytes.push(value);
|
||||
if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
|
||||
fr[kLastProgressEventFired] = Date.now();
|
||||
@@ -15875,9 +15875,9 @@ var require_util6 = __commonJS({
|
||||
}
|
||||
}
|
||||
}
|
||||
function validateCookiePath(path12) {
|
||||
for (let i = 0; i < path12.length; ++i) {
|
||||
const code = path12.charCodeAt(i);
|
||||
function validateCookiePath(path13) {
|
||||
for (let i = 0; i < path13.length; ++i) {
|
||||
const code = path13.charCodeAt(i);
|
||||
if (code < 32 || // exclude CTLs (0-31)
|
||||
code === 127 || // DEL
|
||||
code === 59) {
|
||||
@@ -17540,7 +17540,7 @@ var require_websocket = __commonJS({
|
||||
var { ByteParser } = require_receiver();
|
||||
var { kEnumerableProperty, isBlobLike } = require_util();
|
||||
var { getGlobalDispatcher } = require_global2();
|
||||
var { types } = require("node:util");
|
||||
var { types: types2 } = require("node:util");
|
||||
var { ErrorEvent, CloseEvent } = require_events();
|
||||
var { SendQueue } = require_sender();
|
||||
var WebSocket = class _WebSocket extends EventTarget {
|
||||
@@ -17663,7 +17663,7 @@ var require_websocket = __commonJS({
|
||||
this.#sendQueue.add(data, () => {
|
||||
this.#bufferedAmount -= length;
|
||||
}, sendHints.string);
|
||||
} else if (types.isArrayBuffer(data)) {
|
||||
} else if (types2.isArrayBuffer(data)) {
|
||||
this.#bufferedAmount += data.byteLength;
|
||||
this.#sendQueue.add(data, () => {
|
||||
this.#bufferedAmount -= data.byteLength;
|
||||
@@ -17869,7 +17869,7 @@ var require_websocket = __commonJS({
|
||||
if (isBlobLike(V)) {
|
||||
return webidl.converters.Blob(V, { strict: false });
|
||||
}
|
||||
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
|
||||
if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
|
||||
return webidl.converters.BufferSource(V);
|
||||
}
|
||||
}
|
||||
@@ -18517,11 +18517,11 @@ var require_undici = __commonJS({
|
||||
if (typeof opts.path !== "string") {
|
||||
throw new InvalidArgumentError("invalid opts.path");
|
||||
}
|
||||
let path12 = opts.path;
|
||||
let path13 = opts.path;
|
||||
if (!opts.path.startsWith("/")) {
|
||||
path12 = `/${path12}`;
|
||||
path13 = `/${path13}`;
|
||||
}
|
||||
url2 = new URL(util4.parseOrigin(url2).origin + path12);
|
||||
url2 = new URL(util4.parseOrigin(url2).origin + path13);
|
||||
} else {
|
||||
if (!opts) {
|
||||
opts = typeof url2 === "object" ? url2 : {};
|
||||
@@ -18614,11 +18614,11 @@ var require_concat_map = __commonJS({
|
||||
var require_balanced_match = __commonJS({
|
||||
"node_modules/balanced-match/index.js"(exports2, module2) {
|
||||
"use strict";
|
||||
module2.exports = balanced;
|
||||
function balanced(a, b, str) {
|
||||
if (a instanceof RegExp) a = maybeMatch(a, str);
|
||||
if (b instanceof RegExp) b = maybeMatch(b, str);
|
||||
var r = range2(a, b, str);
|
||||
module2.exports = balanced2;
|
||||
function balanced2(a, b, str) {
|
||||
if (a instanceof RegExp) a = maybeMatch2(a, str);
|
||||
if (b instanceof RegExp) b = maybeMatch2(b, str);
|
||||
var r = range3(a, b, str);
|
||||
return r && {
|
||||
start: r[0],
|
||||
end: r[1],
|
||||
@@ -18627,12 +18627,12 @@ var require_balanced_match = __commonJS({
|
||||
post: str.slice(r[1] + b.length)
|
||||
};
|
||||
}
|
||||
function maybeMatch(reg, str) {
|
||||
function maybeMatch2(reg, str) {
|
||||
var m = str.match(reg);
|
||||
return m ? m[0] : null;
|
||||
}
|
||||
balanced.range = range2;
|
||||
function range2(a, b, str) {
|
||||
balanced2.range = range3;
|
||||
function range3(a, b, str) {
|
||||
var begs, beg, left, right, result;
|
||||
var ai = str.indexOf(a);
|
||||
var bi = str.indexOf(b, ai + 1);
|
||||
@@ -18669,27 +18669,27 @@ var require_balanced_match = __commonJS({
|
||||
var require_brace_expansion = __commonJS({
|
||||
"node_modules/brace-expansion/index.js"(exports2, module2) {
|
||||
var concatMap = require_concat_map();
|
||||
var balanced = require_balanced_match();
|
||||
var balanced2 = require_balanced_match();
|
||||
module2.exports = expandTop;
|
||||
var escSlash = "\0SLASH" + Math.random() + "\0";
|
||||
var escOpen = "\0OPEN" + Math.random() + "\0";
|
||||
var escClose = "\0CLOSE" + Math.random() + "\0";
|
||||
var escComma = "\0COMMA" + Math.random() + "\0";
|
||||
var escPeriod = "\0PERIOD" + Math.random() + "\0";
|
||||
function numeric(str) {
|
||||
var escSlash2 = "\0SLASH" + Math.random() + "\0";
|
||||
var escOpen2 = "\0OPEN" + Math.random() + "\0";
|
||||
var escClose2 = "\0CLOSE" + Math.random() + "\0";
|
||||
var escComma2 = "\0COMMA" + Math.random() + "\0";
|
||||
var escPeriod2 = "\0PERIOD" + Math.random() + "\0";
|
||||
function numeric2(str) {
|
||||
return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
|
||||
}
|
||||
function escapeBraces(str) {
|
||||
return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
|
||||
function escapeBraces2(str) {
|
||||
return str.split("\\\\").join(escSlash2).split("\\{").join(escOpen2).split("\\}").join(escClose2).split("\\,").join(escComma2).split("\\.").join(escPeriod2);
|
||||
}
|
||||
function unescapeBraces(str) {
|
||||
return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
|
||||
function unescapeBraces2(str) {
|
||||
return str.split(escSlash2).join("\\").split(escOpen2).join("{").split(escClose2).join("}").split(escComma2).join(",").split(escPeriod2).join(".");
|
||||
}
|
||||
function parseCommaParts(str) {
|
||||
function parseCommaParts2(str) {
|
||||
if (!str)
|
||||
return [""];
|
||||
var parts = [];
|
||||
var m = balanced("{", "}", str);
|
||||
var m = balanced2("{", "}", str);
|
||||
if (!m)
|
||||
return str.split(",");
|
||||
var pre = m.pre;
|
||||
@@ -18697,7 +18697,7 @@ var require_brace_expansion = __commonJS({
|
||||
var post = m.post;
|
||||
var p = pre.split(",");
|
||||
p[p.length - 1] += "{" + body2 + "}";
|
||||
var postParts = parseCommaParts(post);
|
||||
var postParts = parseCommaParts2(post);
|
||||
if (post.length) {
|
||||
p[p.length - 1] += postParts.shift();
|
||||
p.push.apply(p, postParts);
|
||||
@@ -18711,23 +18711,23 @@ var require_brace_expansion = __commonJS({
|
||||
if (str.substr(0, 2) === "{}") {
|
||||
str = "\\{\\}" + str.substr(2);
|
||||
}
|
||||
return expand(escapeBraces(str), true).map(unescapeBraces);
|
||||
return expand2(escapeBraces2(str), true).map(unescapeBraces2);
|
||||
}
|
||||
function embrace(str) {
|
||||
function embrace2(str) {
|
||||
return "{" + str + "}";
|
||||
}
|
||||
function isPadded(el) {
|
||||
function isPadded2(el) {
|
||||
return /^-?0\d/.test(el);
|
||||
}
|
||||
function lte(i, y) {
|
||||
function lte2(i, y) {
|
||||
return i <= y;
|
||||
}
|
||||
function gte(i, y) {
|
||||
function gte2(i, y) {
|
||||
return i >= y;
|
||||
}
|
||||
function expand(str, isTop) {
|
||||
function expand2(str, isTop) {
|
||||
var expansions = [];
|
||||
var m = balanced("{", "}", str);
|
||||
var m = balanced2("{", "}", str);
|
||||
if (!m || /\$$/.test(m.pre)) return [str];
|
||||
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
|
||||
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
|
||||
@@ -18735,8 +18735,8 @@ var require_brace_expansion = __commonJS({
|
||||
var isOptions = m.body.indexOf(",") >= 0;
|
||||
if (!isSequence && !isOptions) {
|
||||
if (m.post.match(/,(?!,).*\}/)) {
|
||||
str = m.pre + "{" + m.body + escClose + m.post;
|
||||
return expand(str);
|
||||
str = m.pre + "{" + m.body + escClose2 + m.post;
|
||||
return expand2(str);
|
||||
}
|
||||
return [str];
|
||||
}
|
||||
@@ -18744,11 +18744,11 @@ var require_brace_expansion = __commonJS({
|
||||
if (isSequence) {
|
||||
n = m.body.split(/\.\./);
|
||||
} else {
|
||||
n = parseCommaParts(m.body);
|
||||
n = parseCommaParts2(m.body);
|
||||
if (n.length === 1) {
|
||||
n = expand(n[0], false).map(embrace);
|
||||
n = expand2(n[0], false).map(embrace2);
|
||||
if (n.length === 1) {
|
||||
var post = m.post.length ? expand(m.post, false) : [""];
|
||||
var post = m.post.length ? expand2(m.post, false) : [""];
|
||||
return post.map(function(p) {
|
||||
return m.pre + n[0] + p;
|
||||
});
|
||||
@@ -18756,20 +18756,20 @@ var require_brace_expansion = __commonJS({
|
||||
}
|
||||
}
|
||||
var pre = m.pre;
|
||||
var post = m.post.length ? expand(m.post, false) : [""];
|
||||
var post = m.post.length ? expand2(m.post, false) : [""];
|
||||
var N;
|
||||
if (isSequence) {
|
||||
var x = numeric(n[0]);
|
||||
var y = numeric(n[1]);
|
||||
var x = numeric2(n[0]);
|
||||
var y = numeric2(n[1]);
|
||||
var width = Math.max(n[0].length, n[1].length);
|
||||
var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
|
||||
var test = lte;
|
||||
var incr = n.length == 3 ? Math.abs(numeric2(n[2])) : 1;
|
||||
var test = lte2;
|
||||
var reverse = y < x;
|
||||
if (reverse) {
|
||||
incr *= -1;
|
||||
test = gte;
|
||||
test = gte2;
|
||||
}
|
||||
var pad = n.some(isPadded);
|
||||
var pad = n.some(isPadded2);
|
||||
N = [];
|
||||
for (var i = x; test(i, y); i += incr) {
|
||||
var c;
|
||||
@@ -18794,7 +18794,7 @@ var require_brace_expansion = __commonJS({
|
||||
}
|
||||
} else {
|
||||
N = concatMap(n, function(el) {
|
||||
return expand(el, false);
|
||||
return expand2(el, false);
|
||||
});
|
||||
}
|
||||
for (var j = 0; j < N.length; j++) {
|
||||
@@ -18812,9 +18812,9 @@ var require_brace_expansion = __commonJS({
|
||||
// node_modules/minimatch/minimatch.js
|
||||
var require_minimatch = __commonJS({
|
||||
"node_modules/minimatch/minimatch.js"(exports2, module2) {
|
||||
module2.exports = minimatch2;
|
||||
minimatch2.Minimatch = Minimatch2;
|
||||
var path12 = (function() {
|
||||
module2.exports = minimatch3;
|
||||
minimatch3.Minimatch = Minimatch3;
|
||||
var path13 = (function() {
|
||||
try {
|
||||
return require("path");
|
||||
} catch (e) {
|
||||
@@ -18822,9 +18822,9 @@ var require_minimatch = __commonJS({
|
||||
})() || {
|
||||
sep: "/"
|
||||
};
|
||||
minimatch2.sep = path12.sep;
|
||||
var GLOBSTAR = minimatch2.GLOBSTAR = Minimatch2.GLOBSTAR = {};
|
||||
var expand = require_brace_expansion();
|
||||
minimatch3.sep = path13.sep;
|
||||
var GLOBSTAR2 = minimatch3.GLOBSTAR = Minimatch3.GLOBSTAR = {};
|
||||
var expand2 = require_brace_expansion();
|
||||
var plTypes = {
|
||||
"!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
|
||||
"?": { open: "(?:", close: ")?" },
|
||||
@@ -18832,11 +18832,11 @@ var require_minimatch = __commonJS({
|
||||
"*": { open: "(?:", close: ")*" },
|
||||
"@": { open: "(?:", close: ")" }
|
||||
};
|
||||
var qmark = "[^/]";
|
||||
var star = qmark + "*?";
|
||||
var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
|
||||
var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
|
||||
var reSpecials = charSet("().*{}+?[]^$\\!");
|
||||
var qmark3 = "[^/]";
|
||||
var star3 = qmark3 + "*?";
|
||||
var twoStarDot2 = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
|
||||
var twoStarNoDot2 = "(?:(?!(?:\\/|^)\\.).)*?";
|
||||
var reSpecials2 = charSet("().*{}+?[]^$\\!");
|
||||
function charSet(s) {
|
||||
return s.split("").reduce(function(set, c) {
|
||||
set[c] = true;
|
||||
@@ -18844,14 +18844,14 @@ var require_minimatch = __commonJS({
|
||||
}, {});
|
||||
}
|
||||
var slashSplit = /\/+/;
|
||||
minimatch2.filter = filter2;
|
||||
function filter2(pattern, options) {
|
||||
minimatch3.filter = filter3;
|
||||
function filter3(pattern, options) {
|
||||
options = options || {};
|
||||
return function(p, i, list) {
|
||||
return minimatch2(p, pattern, options);
|
||||
return minimatch3(p, pattern, options);
|
||||
};
|
||||
}
|
||||
function ext(a, b) {
|
||||
function ext2(a, b) {
|
||||
b = b || {};
|
||||
var t = {};
|
||||
Object.keys(a).forEach(function(k) {
|
||||
@@ -18862,57 +18862,57 @@ var require_minimatch = __commonJS({
|
||||
});
|
||||
return t;
|
||||
}
|
||||
minimatch2.defaults = function(def) {
|
||||
minimatch3.defaults = function(def) {
|
||||
if (!def || typeof def !== "object" || !Object.keys(def).length) {
|
||||
return minimatch2;
|
||||
return minimatch3;
|
||||
}
|
||||
var orig = minimatch2;
|
||||
var m = function minimatch3(p, pattern, options) {
|
||||
return orig(p, pattern, ext(def, options));
|
||||
var orig = minimatch3;
|
||||
var m = function minimatch4(p, pattern, options) {
|
||||
return orig(p, pattern, ext2(def, options));
|
||||
};
|
||||
m.Minimatch = function Minimatch3(pattern, options) {
|
||||
return new orig.Minimatch(pattern, ext(def, options));
|
||||
m.Minimatch = function Minimatch4(pattern, options) {
|
||||
return new orig.Minimatch(pattern, ext2(def, options));
|
||||
};
|
||||
m.Minimatch.defaults = function defaults(options) {
|
||||
return orig.defaults(ext(def, options)).Minimatch;
|
||||
m.Minimatch.defaults = function defaults2(options) {
|
||||
return orig.defaults(ext2(def, options)).Minimatch;
|
||||
};
|
||||
m.filter = function filter3(pattern, options) {
|
||||
return orig.filter(pattern, ext(def, options));
|
||||
m.filter = function filter4(pattern, options) {
|
||||
return orig.filter(pattern, ext2(def, options));
|
||||
};
|
||||
m.defaults = function defaults(options) {
|
||||
return orig.defaults(ext(def, options));
|
||||
m.defaults = function defaults2(options) {
|
||||
return orig.defaults(ext2(def, options));
|
||||
};
|
||||
m.makeRe = function makeRe2(pattern, options) {
|
||||
return orig.makeRe(pattern, ext(def, options));
|
||||
m.makeRe = function makeRe3(pattern, options) {
|
||||
return orig.makeRe(pattern, ext2(def, options));
|
||||
};
|
||||
m.braceExpand = function braceExpand2(pattern, options) {
|
||||
return orig.braceExpand(pattern, ext(def, options));
|
||||
m.braceExpand = function braceExpand3(pattern, options) {
|
||||
return orig.braceExpand(pattern, ext2(def, options));
|
||||
};
|
||||
m.match = function(list, pattern, options) {
|
||||
return orig.match(list, pattern, ext(def, options));
|
||||
return orig.match(list, pattern, ext2(def, options));
|
||||
};
|
||||
return m;
|
||||
};
|
||||
Minimatch2.defaults = function(def) {
|
||||
return minimatch2.defaults(def).Minimatch;
|
||||
Minimatch3.defaults = function(def) {
|
||||
return minimatch3.defaults(def).Minimatch;
|
||||
};
|
||||
function minimatch2(p, pattern, options) {
|
||||
assertValidPattern(pattern);
|
||||
function minimatch3(p, pattern, options) {
|
||||
assertValidPattern2(pattern);
|
||||
if (!options) options = {};
|
||||
if (!options.nocomment && pattern.charAt(0) === "#") {
|
||||
return false;
|
||||
}
|
||||
return new Minimatch2(pattern, options).match(p);
|
||||
return new Minimatch3(pattern, options).match(p);
|
||||
}
|
||||
function Minimatch2(pattern, options) {
|
||||
if (!(this instanceof Minimatch2)) {
|
||||
return new Minimatch2(pattern, options);
|
||||
function Minimatch3(pattern, options) {
|
||||
if (!(this instanceof Minimatch3)) {
|
||||
return new Minimatch3(pattern, options);
|
||||
}
|
||||
assertValidPattern(pattern);
|
||||
assertValidPattern2(pattern);
|
||||
if (!options) options = {};
|
||||
pattern = pattern.trim();
|
||||
if (!options.allowWindowsEscape && path12.sep !== "/") {
|
||||
pattern = pattern.split(path12.sep).join("/");
|
||||
if (!options.allowWindowsEscape && path13.sep !== "/") {
|
||||
pattern = pattern.split(path13.sep).join("/");
|
||||
}
|
||||
this.options = options;
|
||||
this.set = [];
|
||||
@@ -18924,9 +18924,9 @@ var require_minimatch = __commonJS({
|
||||
this.partial = !!options.partial;
|
||||
this.make();
|
||||
}
|
||||
Minimatch2.prototype.debug = function() {
|
||||
Minimatch3.prototype.debug = function() {
|
||||
};
|
||||
Minimatch2.prototype.make = make;
|
||||
Minimatch3.prototype.make = make;
|
||||
function make() {
|
||||
var pattern = this.pattern;
|
||||
var options = this.options;
|
||||
@@ -18958,7 +18958,7 @@ var require_minimatch = __commonJS({
|
||||
this.debug(this.pattern, set);
|
||||
this.set = set;
|
||||
}
|
||||
Minimatch2.prototype.parseNegate = parseNegate;
|
||||
Minimatch3.prototype.parseNegate = parseNegate;
|
||||
function parseNegate() {
|
||||
var pattern = this.pattern;
|
||||
var negate = false;
|
||||
@@ -18972,42 +18972,42 @@ var require_minimatch = __commonJS({
|
||||
if (negateOffset) this.pattern = pattern.substr(negateOffset);
|
||||
this.negate = negate;
|
||||
}
|
||||
minimatch2.braceExpand = function(pattern, options) {
|
||||
return braceExpand(pattern, options);
|
||||
minimatch3.braceExpand = function(pattern, options) {
|
||||
return braceExpand2(pattern, options);
|
||||
};
|
||||
Minimatch2.prototype.braceExpand = braceExpand;
|
||||
function braceExpand(pattern, options) {
|
||||
Minimatch3.prototype.braceExpand = braceExpand2;
|
||||
function braceExpand2(pattern, options) {
|
||||
if (!options) {
|
||||
if (this instanceof Minimatch2) {
|
||||
if (this instanceof Minimatch3) {
|
||||
options = this.options;
|
||||
} else {
|
||||
options = {};
|
||||
}
|
||||
}
|
||||
pattern = typeof pattern === "undefined" ? this.pattern : pattern;
|
||||
assertValidPattern(pattern);
|
||||
assertValidPattern2(pattern);
|
||||
if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
|
||||
return [pattern];
|
||||
}
|
||||
return expand(pattern);
|
||||
return expand2(pattern);
|
||||
}
|
||||
var MAX_PATTERN_LENGTH = 1024 * 64;
|
||||
var assertValidPattern = function(pattern) {
|
||||
var MAX_PATTERN_LENGTH2 = 1024 * 64;
|
||||
var assertValidPattern2 = function(pattern) {
|
||||
if (typeof pattern !== "string") {
|
||||
throw new TypeError("invalid pattern");
|
||||
}
|
||||
if (pattern.length > MAX_PATTERN_LENGTH) {
|
||||
if (pattern.length > MAX_PATTERN_LENGTH2) {
|
||||
throw new TypeError("pattern is too long");
|
||||
}
|
||||
};
|
||||
Minimatch2.prototype.parse = parse4;
|
||||
Minimatch3.prototype.parse = parse4;
|
||||
var SUBPARSE = {};
|
||||
function parse4(pattern, isSub) {
|
||||
assertValidPattern(pattern);
|
||||
assertValidPattern2(pattern);
|
||||
var options = this.options;
|
||||
if (pattern === "**") {
|
||||
if (!options.noglobstar)
|
||||
return GLOBSTAR;
|
||||
return GLOBSTAR2;
|
||||
else
|
||||
pattern = "*";
|
||||
}
|
||||
@@ -19027,11 +19027,11 @@ var require_minimatch = __commonJS({
|
||||
if (stateChar) {
|
||||
switch (stateChar) {
|
||||
case "*":
|
||||
re += star;
|
||||
re += star3;
|
||||
hasMagic = true;
|
||||
break;
|
||||
case "?":
|
||||
re += qmark;
|
||||
re += qmark3;
|
||||
hasMagic = true;
|
||||
break;
|
||||
default:
|
||||
@@ -19044,7 +19044,7 @@ var require_minimatch = __commonJS({
|
||||
}
|
||||
for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
|
||||
this.debug("%s %s %s %j", pattern, i, re, c);
|
||||
if (escaping && reSpecials[c]) {
|
||||
if (escaping && reSpecials2[c]) {
|
||||
re += "\\" + c;
|
||||
escaping = false;
|
||||
continue;
|
||||
@@ -19156,7 +19156,7 @@ var require_minimatch = __commonJS({
|
||||
clearStateChar();
|
||||
if (escaping) {
|
||||
escaping = false;
|
||||
} else if (reSpecials[c] && !(c === "^" && inClass)) {
|
||||
} else if (reSpecials2[c] && !(c === "^" && inClass)) {
|
||||
re += "\\";
|
||||
}
|
||||
re += c;
|
||||
@@ -19178,7 +19178,7 @@ var require_minimatch = __commonJS({
|
||||
return $1 + $1 + $2 + "|";
|
||||
});
|
||||
this.debug("tail=%j\n %s", tail, tail, pl, re);
|
||||
var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
|
||||
var t = pl.type === "*" ? star3 : pl.type === "?" ? qmark3 : "\\" + pl.type;
|
||||
hasMagic = true;
|
||||
re = re.slice(0, pl.reStart) + t + "\\(" + tail;
|
||||
}
|
||||
@@ -19186,12 +19186,12 @@ var require_minimatch = __commonJS({
|
||||
if (escaping) {
|
||||
re += "\\\\";
|
||||
}
|
||||
var addPatternStart = false;
|
||||
var addPatternStart2 = false;
|
||||
switch (re.charAt(0)) {
|
||||
case "[":
|
||||
case ".":
|
||||
case "(":
|
||||
addPatternStart = true;
|
||||
addPatternStart2 = true;
|
||||
}
|
||||
for (var n = negativeLists.length - 1; n > -1; n--) {
|
||||
var nl = negativeLists[n];
|
||||
@@ -19216,7 +19216,7 @@ var require_minimatch = __commonJS({
|
||||
if (re !== "" && hasMagic) {
|
||||
re = "(?=.)" + re;
|
||||
}
|
||||
if (addPatternStart) {
|
||||
if (addPatternStart2) {
|
||||
re = patternStart + re;
|
||||
}
|
||||
if (isSub === SUBPARSE) {
|
||||
@@ -19235,11 +19235,11 @@ var require_minimatch = __commonJS({
|
||||
regExp._src = re;
|
||||
return regExp;
|
||||
}
|
||||
minimatch2.makeRe = function(pattern, options) {
|
||||
return new Minimatch2(pattern, options || {}).makeRe();
|
||||
minimatch3.makeRe = function(pattern, options) {
|
||||
return new Minimatch3(pattern, options || {}).makeRe();
|
||||
};
|
||||
Minimatch2.prototype.makeRe = makeRe;
|
||||
function makeRe() {
|
||||
Minimatch3.prototype.makeRe = makeRe2;
|
||||
function makeRe2() {
|
||||
if (this.regexp || this.regexp === false) return this.regexp;
|
||||
var set = this.set;
|
||||
if (!set.length) {
|
||||
@@ -19247,11 +19247,11 @@ var require_minimatch = __commonJS({
|
||||
return this.regexp;
|
||||
}
|
||||
var options = this.options;
|
||||
var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
|
||||
var twoStar = options.noglobstar ? star3 : options.dot ? twoStarDot2 : twoStarNoDot2;
|
||||
var flags = options.nocase ? "i" : "";
|
||||
var re = set.map(function(pattern) {
|
||||
return pattern.map(function(p) {
|
||||
return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
|
||||
return p === GLOBSTAR2 ? twoStar : typeof p === "string" ? regExpEscape3(p) : p._src;
|
||||
}).join("\\/");
|
||||
}).join("|");
|
||||
re = "^(?:" + re + ")$";
|
||||
@@ -19263,9 +19263,9 @@ var require_minimatch = __commonJS({
|
||||
}
|
||||
return this.regexp;
|
||||
}
|
||||
minimatch2.match = function(list, pattern, options) {
|
||||
minimatch3.match = function(list, pattern, options) {
|
||||
options = options || {};
|
||||
var mm = new Minimatch2(pattern, options);
|
||||
var mm = new Minimatch3(pattern, options);
|
||||
list = list.filter(function(f) {
|
||||
return mm.match(f);
|
||||
});
|
||||
@@ -19274,15 +19274,15 @@ var require_minimatch = __commonJS({
|
||||
}
|
||||
return list;
|
||||
};
|
||||
Minimatch2.prototype.match = function match2(f, partial) {
|
||||
Minimatch3.prototype.match = function match4(f, partial) {
|
||||
if (typeof partial === "undefined") partial = this.partial;
|
||||
this.debug("match", f, this.pattern);
|
||||
if (this.comment) return false;
|
||||
if (this.empty) return f === "";
|
||||
if (f === "/" && partial) return true;
|
||||
var options = this.options;
|
||||
if (path12.sep !== "/") {
|
||||
f = f.split(path12.sep).join("/");
|
||||
if (path13.sep !== "/") {
|
||||
f = f.split(path13.sep).join("/");
|
||||
}
|
||||
f = f.split(slashSplit);
|
||||
this.debug(this.pattern, "split", f);
|
||||
@@ -19309,7 +19309,7 @@ var require_minimatch = __commonJS({
|
||||
if (options.flipNegate) return false;
|
||||
return this.negate;
|
||||
};
|
||||
Minimatch2.prototype.matchOne = function(file, pattern, partial) {
|
||||
Minimatch3.prototype.matchOne = function(file, pattern, partial) {
|
||||
var options = this.options;
|
||||
this.debug(
|
||||
"matchOne",
|
||||
@@ -19322,7 +19322,7 @@ var require_minimatch = __commonJS({
|
||||
var f = file[fi];
|
||||
this.debug(pattern, p, f);
|
||||
if (p === false) return false;
|
||||
if (p === GLOBSTAR) {
|
||||
if (p === GLOBSTAR2) {
|
||||
this.debug("GLOBSTAR", [pattern, p, f]);
|
||||
var fr = fi;
|
||||
var pr = pi + 1;
|
||||
@@ -19376,7 +19376,7 @@ var require_minimatch = __commonJS({
|
||||
function globUnescape(s) {
|
||||
return s.replace(/\\(.)/g, "$1");
|
||||
}
|
||||
function regExpEscape(s) {
|
||||
function regExpEscape3(s) {
|
||||
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
||||
}
|
||||
}
|
||||
@@ -19535,13 +19535,13 @@ var require_parse_options = __commonJS({
|
||||
var require_identifiers = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/internal/identifiers.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var numeric = /^[0-9]+$/;
|
||||
var numeric2 = /^[0-9]+$/;
|
||||
var compareIdentifiers = (a, b) => {
|
||||
if (typeof a === "number" && typeof b === "number") {
|
||||
return a === b ? 0 : a < b ? -1 : 1;
|
||||
}
|
||||
const anum = numeric.test(a);
|
||||
const bnum = numeric.test(b);
|
||||
const anum = numeric2.test(a);
|
||||
const bnum = numeric2.test(b);
|
||||
if (anum && bnum) {
|
||||
a = +a;
|
||||
b = +b;
|
||||
@@ -19725,8 +19725,8 @@ var require_semver = __commonJS({
|
||||
throw new Error("invalid increment argument: identifier is empty");
|
||||
}
|
||||
if (identifier) {
|
||||
const match2 = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
|
||||
if (!match2 || match2[1] !== identifier) {
|
||||
const match4 = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
|
||||
if (!match4 || match4[1] !== identifier) {
|
||||
throw new Error(`invalid identifier: ${identifier}`);
|
||||
}
|
||||
}
|
||||
@@ -20103,8 +20103,8 @@ var require_gte = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/functions/gte.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var compare2 = require_compare();
|
||||
var gte = (a, b, loose) => compare2(a, b, loose) >= 0;
|
||||
module2.exports = gte;
|
||||
var gte2 = (a, b, loose) => compare2(a, b, loose) >= 0;
|
||||
module2.exports = gte2;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -20113,8 +20113,8 @@ var require_lte = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/functions/lte.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var compare2 = require_compare();
|
||||
var lte = (a, b, loose) => compare2(a, b, loose) <= 0;
|
||||
module2.exports = lte;
|
||||
var lte2 = (a, b, loose) => compare2(a, b, loose) <= 0;
|
||||
module2.exports = lte2;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -20125,9 +20125,9 @@ var require_cmp = __commonJS({
|
||||
var eq2 = require_eq();
|
||||
var neq = require_neq();
|
||||
var gt2 = require_gt();
|
||||
var gte = require_gte();
|
||||
var gte2 = require_gte();
|
||||
var lt2 = require_lt();
|
||||
var lte = require_lte();
|
||||
var lte2 = require_lte();
|
||||
var cmp = (a, op, b, loose) => {
|
||||
switch (op) {
|
||||
case "===":
|
||||
@@ -20155,11 +20155,11 @@ var require_cmp = __commonJS({
|
||||
case ">":
|
||||
return gt2(a, b, loose);
|
||||
case ">=":
|
||||
return gte(a, b, loose);
|
||||
return gte2(a, b, loose);
|
||||
case "<":
|
||||
return lt2(a, b, loose);
|
||||
case "<=":
|
||||
return lte(a, b, loose);
|
||||
return lte2(a, b, loose);
|
||||
default:
|
||||
throw new TypeError(`Invalid operator: ${op}`);
|
||||
}
|
||||
@@ -20186,28 +20186,28 @@ var require_coerce = __commonJS({
|
||||
return null;
|
||||
}
|
||||
options = options || {};
|
||||
let match2 = null;
|
||||
let match4 = null;
|
||||
if (!options.rtl) {
|
||||
match2 = version3.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
|
||||
match4 = version3.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
|
||||
} else {
|
||||
const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
|
||||
let next;
|
||||
while ((next = coerceRtlRegex.exec(version3)) && (!match2 || match2.index + match2[0].length !== version3.length)) {
|
||||
if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
|
||||
match2 = next;
|
||||
while ((next = coerceRtlRegex.exec(version3)) && (!match4 || match4.index + match4[0].length !== version3.length)) {
|
||||
if (!match4 || next.index + next[0].length !== match4.index + match4[0].length) {
|
||||
match4 = next;
|
||||
}
|
||||
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
|
||||
}
|
||||
coerceRtlRegex.lastIndex = -1;
|
||||
}
|
||||
if (match2 === null) {
|
||||
if (match4 === null) {
|
||||
return null;
|
||||
}
|
||||
const major2 = match2[2];
|
||||
const minor2 = match2[3] || "0";
|
||||
const patch2 = match2[4] || "0";
|
||||
const prerelease = options.includePrerelease && match2[5] ? `-${match2[5]}` : "";
|
||||
const build = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
|
||||
const major2 = match4[2];
|
||||
const minor2 = match4[3] || "0";
|
||||
const patch2 = match4[4] || "0";
|
||||
const prerelease = options.includePrerelease && match4[5] ? `-${match4[5]}` : "";
|
||||
const build = options.includePrerelease && match4[6] ? `+${match4[6]}` : "";
|
||||
return parse4(`${major2}.${minor2}.${patch2}${prerelease}${build}`, options);
|
||||
};
|
||||
module2.exports = coerce;
|
||||
@@ -20258,25 +20258,25 @@ var require_range = __commonJS({
|
||||
"use strict";
|
||||
var SPACE_CHARACTERS = /\s+/g;
|
||||
var Range = class _Range {
|
||||
constructor(range2, options) {
|
||||
constructor(range3, options) {
|
||||
options = parseOptions(options);
|
||||
if (range2 instanceof _Range) {
|
||||
if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
|
||||
return range2;
|
||||
if (range3 instanceof _Range) {
|
||||
if (range3.loose === !!options.loose && range3.includePrerelease === !!options.includePrerelease) {
|
||||
return range3;
|
||||
} else {
|
||||
return new _Range(range2.raw, options);
|
||||
return new _Range(range3.raw, options);
|
||||
}
|
||||
}
|
||||
if (range2 instanceof Comparator) {
|
||||
this.raw = range2.value;
|
||||
this.set = [[range2]];
|
||||
if (range3 instanceof Comparator) {
|
||||
this.raw = range3.value;
|
||||
this.set = [[range3]];
|
||||
this.formatted = void 0;
|
||||
return this;
|
||||
}
|
||||
this.options = options;
|
||||
this.loose = !!options.loose;
|
||||
this.includePrerelease = !!options.includePrerelease;
|
||||
this.raw = range2.trim().replace(SPACE_CHARACTERS, " ");
|
||||
this.raw = range3.trim().replace(SPACE_CHARACTERS, " ");
|
||||
this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
|
||||
if (!this.set.length) {
|
||||
throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
|
||||
@@ -20321,24 +20321,24 @@ var require_range = __commonJS({
|
||||
toString() {
|
||||
return this.range;
|
||||
}
|
||||
parseRange(range2) {
|
||||
parseRange(range3) {
|
||||
const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
|
||||
const memoKey = memoOpts + ":" + range2;
|
||||
const memoKey = memoOpts + ":" + range3;
|
||||
const cached = cache.get(memoKey);
|
||||
if (cached) {
|
||||
return cached;
|
||||
}
|
||||
const loose = this.options.loose;
|
||||
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
|
||||
range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
|
||||
debug3("hyphen replace", range2);
|
||||
range2 = range2.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
|
||||
debug3("comparator trim", range2);
|
||||
range2 = range2.replace(re[t.TILDETRIM], tildeTrimReplace);
|
||||
debug3("tilde trim", range2);
|
||||
range2 = range2.replace(re[t.CARETTRIM], caretTrimReplace);
|
||||
debug3("caret trim", range2);
|
||||
let rangeList = range2.split(" ").map((comp26) => parseComparator(comp26, this.options)).join(" ").split(/\s+/).map((comp26) => replaceGTE0(comp26, this.options));
|
||||
range3 = range3.replace(hr, hyphenReplace(this.options.includePrerelease));
|
||||
debug3("hyphen replace", range3);
|
||||
range3 = range3.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
|
||||
debug3("comparator trim", range3);
|
||||
range3 = range3.replace(re[t.TILDETRIM], tildeTrimReplace);
|
||||
debug3("tilde trim", range3);
|
||||
range3 = range3.replace(re[t.CARETTRIM], caretTrimReplace);
|
||||
debug3("caret trim", range3);
|
||||
let rangeList = range3.split(" ").map((comp26) => parseComparator(comp26, this.options)).join(" ").split(/\s+/).map((comp26) => replaceGTE0(comp26, this.options));
|
||||
if (loose) {
|
||||
rangeList = rangeList.filter((comp26) => {
|
||||
debug3("loose invalid filter", comp26, this.options);
|
||||
@@ -20361,12 +20361,12 @@ var require_range = __commonJS({
|
||||
cache.set(memoKey, result);
|
||||
return result;
|
||||
}
|
||||
intersects(range2, options) {
|
||||
if (!(range2 instanceof _Range)) {
|
||||
intersects(range3, options) {
|
||||
if (!(range3 instanceof _Range)) {
|
||||
throw new TypeError("a Range is required");
|
||||
}
|
||||
return this.set.some((thisComparators) => {
|
||||
return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => {
|
||||
return isSatisfiable(thisComparators, options) && range3.set.some((rangeComparators) => {
|
||||
return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
|
||||
return rangeComparators.every((rangeComparator) => {
|
||||
return thisComparator.intersects(rangeComparator, options);
|
||||
@@ -20747,13 +20747,13 @@ var require_satisfies = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/functions/satisfies.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var Range = require_range();
|
||||
var satisfies2 = (version3, range2, options) => {
|
||||
var satisfies2 = (version3, range3, options) => {
|
||||
try {
|
||||
range2 = new Range(range2, options);
|
||||
range3 = new Range(range3, options);
|
||||
} catch (er) {
|
||||
return false;
|
||||
}
|
||||
return range2.test(version3);
|
||||
return range3.test(version3);
|
||||
};
|
||||
module2.exports = satisfies2;
|
||||
}
|
||||
@@ -20764,7 +20764,7 @@ var require_to_comparators = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var Range = require_range();
|
||||
var toComparators = (range2, options) => new Range(range2, options).set.map((comp26) => comp26.map((c) => c.value).join(" ").trim().split(" "));
|
||||
var toComparators = (range3, options) => new Range(range3, options).set.map((comp26) => comp26.map((c) => c.value).join(" ").trim().split(" "));
|
||||
module2.exports = toComparators;
|
||||
}
|
||||
});
|
||||
@@ -20775,12 +20775,12 @@ var require_max_satisfying = __commonJS({
|
||||
"use strict";
|
||||
var SemVer = require_semver();
|
||||
var Range = require_range();
|
||||
var maxSatisfying2 = (versions, range2, options) => {
|
||||
var maxSatisfying2 = (versions, range3, options) => {
|
||||
let max = null;
|
||||
let maxSV = null;
|
||||
let rangeObj = null;
|
||||
try {
|
||||
rangeObj = new Range(range2, options);
|
||||
rangeObj = new Range(range3, options);
|
||||
} catch (er) {
|
||||
return null;
|
||||
}
|
||||
@@ -20804,12 +20804,12 @@ var require_min_satisfying = __commonJS({
|
||||
"use strict";
|
||||
var SemVer = require_semver();
|
||||
var Range = require_range();
|
||||
var minSatisfying2 = (versions, range2, options) => {
|
||||
var minSatisfying2 = (versions, range3, options) => {
|
||||
let min = null;
|
||||
let minSV = null;
|
||||
let rangeObj = null;
|
||||
try {
|
||||
rangeObj = new Range(range2, options);
|
||||
rangeObj = new Range(range3, options);
|
||||
} catch (er) {
|
||||
return null;
|
||||
}
|
||||
@@ -20834,19 +20834,19 @@ var require_min_version = __commonJS({
|
||||
var SemVer = require_semver();
|
||||
var Range = require_range();
|
||||
var gt2 = require_gt();
|
||||
var minVersion = (range2, loose) => {
|
||||
range2 = new Range(range2, loose);
|
||||
var minVersion = (range3, loose) => {
|
||||
range3 = new Range(range3, loose);
|
||||
let minver = new SemVer("0.0.0");
|
||||
if (range2.test(minver)) {
|
||||
if (range3.test(minver)) {
|
||||
return minver;
|
||||
}
|
||||
minver = new SemVer("0.0.0-0");
|
||||
if (range2.test(minver)) {
|
||||
if (range3.test(minver)) {
|
||||
return minver;
|
||||
}
|
||||
minver = null;
|
||||
for (let i = 0; i < range2.set.length; ++i) {
|
||||
const comparators = range2.set[i];
|
||||
for (let i = 0; i < range3.set.length; ++i) {
|
||||
const comparators = range3.set[i];
|
||||
let setMin = null;
|
||||
comparators.forEach((comparator) => {
|
||||
const compver = new SemVer(comparator.semver.version);
|
||||
@@ -20877,7 +20877,7 @@ var require_min_version = __commonJS({
|
||||
minver = setMin;
|
||||
}
|
||||
}
|
||||
if (minver && range2.test(minver)) {
|
||||
if (minver && range3.test(minver)) {
|
||||
return minver;
|
||||
}
|
||||
return null;
|
||||
@@ -20891,9 +20891,9 @@ var require_valid2 = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/ranges/valid.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var Range = require_range();
|
||||
var validRange2 = (range2, options) => {
|
||||
var validRange2 = (range3, options) => {
|
||||
try {
|
||||
return new Range(range2, options).range || "*";
|
||||
return new Range(range3, options).range || "*";
|
||||
} catch (er) {
|
||||
return null;
|
||||
}
|
||||
@@ -20913,23 +20913,23 @@ var require_outside = __commonJS({
|
||||
var satisfies2 = require_satisfies();
|
||||
var gt2 = require_gt();
|
||||
var lt2 = require_lt();
|
||||
var lte = require_lte();
|
||||
var gte = require_gte();
|
||||
var outside = (version3, range2, hilo, options) => {
|
||||
var lte2 = require_lte();
|
||||
var gte2 = require_gte();
|
||||
var outside = (version3, range3, hilo, options) => {
|
||||
version3 = new SemVer(version3, options);
|
||||
range2 = new Range(range2, options);
|
||||
range3 = new Range(range3, options);
|
||||
let gtfn, ltefn, ltfn, comp26, ecomp;
|
||||
switch (hilo) {
|
||||
case ">":
|
||||
gtfn = gt2;
|
||||
ltefn = lte;
|
||||
ltefn = lte2;
|
||||
ltfn = lt2;
|
||||
comp26 = ">";
|
||||
ecomp = ">=";
|
||||
break;
|
||||
case "<":
|
||||
gtfn = lt2;
|
||||
ltefn = gte;
|
||||
ltefn = gte2;
|
||||
ltfn = gt2;
|
||||
comp26 = "<";
|
||||
ecomp = "<=";
|
||||
@@ -20937,11 +20937,11 @@ var require_outside = __commonJS({
|
||||
default:
|
||||
throw new TypeError('Must provide a hilo val of "<" or ">"');
|
||||
}
|
||||
if (satisfies2(version3, range2, options)) {
|
||||
if (satisfies2(version3, range3, options)) {
|
||||
return false;
|
||||
}
|
||||
for (let i = 0; i < range2.set.length; ++i) {
|
||||
const comparators = range2.set[i];
|
||||
for (let i = 0; i < range3.set.length; ++i) {
|
||||
const comparators = range3.set[i];
|
||||
let high = null;
|
||||
let low = null;
|
||||
comparators.forEach((comparator) => {
|
||||
@@ -20976,7 +20976,7 @@ var require_gtr = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/ranges/gtr.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var outside = require_outside();
|
||||
var gtr = (version3, range2, options) => outside(version3, range2, ">", options);
|
||||
var gtr = (version3, range3, options) => outside(version3, range3, ">", options);
|
||||
module2.exports = gtr;
|
||||
}
|
||||
});
|
||||
@@ -20986,7 +20986,7 @@ var require_ltr = __commonJS({
|
||||
"node_modules/@actions/cache/node_modules/semver/ranges/ltr.js"(exports2, module2) {
|
||||
"use strict";
|
||||
var outside = require_outside();
|
||||
var ltr = (version3, range2, options) => outside(version3, range2, "<", options);
|
||||
var ltr = (version3, range3, options) => outside(version3, range3, "<", options);
|
||||
module2.exports = ltr;
|
||||
}
|
||||
});
|
||||
@@ -21011,13 +21011,13 @@ var require_simplify = __commonJS({
|
||||
"use strict";
|
||||
var satisfies2 = require_satisfies();
|
||||
var compare2 = require_compare();
|
||||
module2.exports = (versions, range2, options) => {
|
||||
module2.exports = (versions, range3, options) => {
|
||||
const set = [];
|
||||
let first = null;
|
||||
let prev = null;
|
||||
const v = versions.sort((a, b) => compare2(a, b, options));
|
||||
for (const version3 of v) {
|
||||
const included = satisfies2(version3, range2, options);
|
||||
const included = satisfies2(version3, range3, options);
|
||||
if (included) {
|
||||
prev = version3;
|
||||
if (!first) {
|
||||
@@ -21049,8 +21049,8 @@ var require_simplify = __commonJS({
|
||||
}
|
||||
}
|
||||
const simplified = ranges.join(" || ");
|
||||
const original = typeof range2.raw === "string" ? range2.raw : String(range2);
|
||||
return simplified.length < original.length ? simplified : range2;
|
||||
const original = typeof range3.raw === "string" ? range3.raw : String(range3);
|
||||
return simplified.length < original.length ? simplified : range3;
|
||||
};
|
||||
}
|
||||
});
|
||||
@@ -21244,8 +21244,8 @@ var require_semver2 = __commonJS({
|
||||
var lt2 = require_lt();
|
||||
var eq2 = require_eq();
|
||||
var neq = require_neq();
|
||||
var gte = require_gte();
|
||||
var lte = require_lte();
|
||||
var gte2 = require_gte();
|
||||
var lte2 = require_lte();
|
||||
var cmp = require_cmp();
|
||||
var coerce = require_coerce();
|
||||
var Comparator = require_comparator();
|
||||
@@ -21282,8 +21282,8 @@ var require_semver2 = __commonJS({
|
||||
lt: lt2,
|
||||
eq: eq2,
|
||||
neq,
|
||||
gte,
|
||||
lte,
|
||||
gte: gte2,
|
||||
lte: lte2,
|
||||
cmp,
|
||||
coerce,
|
||||
Comparator,
|
||||
@@ -21338,14 +21338,14 @@ var require_ms = __commonJS({
|
||||
if (str.length > 100) {
|
||||
return;
|
||||
}
|
||||
var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
|
||||
var match4 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
|
||||
str
|
||||
);
|
||||
if (!match2) {
|
||||
if (!match4) {
|
||||
return;
|
||||
}
|
||||
var n = parseFloat(match2[1]);
|
||||
var type = (match2[2] || "ms").toLowerCase();
|
||||
var n = parseFloat(match4[1]);
|
||||
var type = (match4[2] || "ms").toLowerCase();
|
||||
switch (type) {
|
||||
case "years":
|
||||
case "year":
|
||||
@@ -21476,19 +21476,19 @@ var require_common = __commonJS({
|
||||
args.unshift("%O");
|
||||
}
|
||||
let index = 0;
|
||||
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format) => {
|
||||
if (match2 === "%%") {
|
||||
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match4, format) => {
|
||||
if (match4 === "%%") {
|
||||
return "%";
|
||||
}
|
||||
index++;
|
||||
const formatter = createDebug.formatters[format];
|
||||
if (typeof formatter === "function") {
|
||||
const val = args[index];
|
||||
match2 = formatter.call(self2, val);
|
||||
match4 = formatter.call(self2, val);
|
||||
args.splice(index, 1);
|
||||
index--;
|
||||
}
|
||||
return match2;
|
||||
return match4;
|
||||
});
|
||||
createDebug.formatArgs.call(self2, args);
|
||||
const logFn = self2.log || createDebug.log;
|
||||
@@ -21708,12 +21708,12 @@ var require_browser = __commonJS({
|
||||
args.splice(1, 0, c, "color: inherit");
|
||||
let index = 0;
|
||||
let lastC = 0;
|
||||
args[0].replace(/%[a-zA-Z%]/g, (match2) => {
|
||||
if (match2 === "%%") {
|
||||
args[0].replace(/%[a-zA-Z%]/g, (match4) => {
|
||||
if (match4 === "%%") {
|
||||
return;
|
||||
}
|
||||
index++;
|
||||
if (match2 === "%c") {
|
||||
if (match4 === "%c") {
|
||||
lastC = index;
|
||||
}
|
||||
});
|
||||
@@ -23844,9 +23844,9 @@ var require_json_format_contract = __commonJS({
|
||||
}
|
||||
exports2.jsonWriteOptions = jsonWriteOptions;
|
||||
function mergeJsonOptions(a, b) {
|
||||
var _a, _b;
|
||||
var _a2, _b;
|
||||
let c = Object.assign(Object.assign({}, a), b);
|
||||
c.typeRegistry = [...(_a = a === null || a === void 0 ? void 0 : a.typeRegistry) !== null && _a !== void 0 ? _a : [], ...(_b = b === null || b === void 0 ? void 0 : b.typeRegistry) !== null && _b !== void 0 ? _b : []];
|
||||
c.typeRegistry = [...(_a2 = a === null || a === void 0 ? void 0 : a.typeRegistry) !== null && _a2 !== void 0 ? _a2 : [], ...(_b = b === null || b === void 0 ? void 0 : b.typeRegistry) !== null && _b !== void 0 ? _b : []];
|
||||
return c;
|
||||
}
|
||||
exports2.mergeJsonOptions = mergeJsonOptions;
|
||||
@@ -23932,8 +23932,8 @@ var require_reflection_info = __commonJS({
|
||||
RepeatType2[RepeatType2["UNPACKED"] = 2] = "UNPACKED";
|
||||
})(RepeatType = exports2.RepeatType || (exports2.RepeatType = {}));
|
||||
function normalizeFieldInfo(field) {
|
||||
var _a, _b, _c, _d;
|
||||
field.localName = (_a = field.localName) !== null && _a !== void 0 ? _a : lower_camel_case_1.lowerCamelCase(field.name);
|
||||
var _a2, _b, _c, _d;
|
||||
field.localName = (_a2 = field.localName) !== null && _a2 !== void 0 ? _a2 : lower_camel_case_1.lowerCamelCase(field.name);
|
||||
field.jsonName = (_b = field.jsonName) !== null && _b !== void 0 ? _b : lower_camel_case_1.lowerCamelCase(field.name);
|
||||
field.repeat = (_c = field.repeat) !== null && _c !== void 0 ? _c : RepeatType.NO;
|
||||
field.opt = (_d = field.opt) !== null && _d !== void 0 ? _d : field.repeat ? false : field.oneof ? false : field.kind == "message";
|
||||
@@ -23941,14 +23941,14 @@ var require_reflection_info = __commonJS({
|
||||
}
|
||||
exports2.normalizeFieldInfo = normalizeFieldInfo;
|
||||
function readFieldOptions(messageType, fieldName, extensionName, extensionType) {
|
||||
var _a;
|
||||
const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options;
|
||||
var _a2;
|
||||
const options = (_a2 = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a2 === void 0 ? void 0 : _a2.options;
|
||||
return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : void 0;
|
||||
}
|
||||
exports2.readFieldOptions = readFieldOptions;
|
||||
function readFieldOption(messageType, fieldName, extensionName, extensionType) {
|
||||
var _a;
|
||||
const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options;
|
||||
var _a2;
|
||||
const options = (_a2 = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a2 === void 0 ? void 0 : _a2.options;
|
||||
if (!options) {
|
||||
return void 0;
|
||||
}
|
||||
@@ -24044,8 +24044,8 @@ var require_reflection_type_check = __commonJS({
|
||||
var oneof_1 = require_oneof();
|
||||
var ReflectionTypeCheck = class {
|
||||
constructor(info3) {
|
||||
var _a;
|
||||
this.fields = (_a = info3.fields) !== null && _a !== void 0 ? _a : [];
|
||||
var _a2;
|
||||
this.fields = (_a2 = info3.fields) !== null && _a2 !== void 0 ? _a2 : [];
|
||||
}
|
||||
prepare() {
|
||||
if (this.data)
|
||||
@@ -24295,10 +24295,10 @@ var require_reflection_json_reader = __commonJS({
|
||||
this.info = info3;
|
||||
}
|
||||
prepare() {
|
||||
var _a;
|
||||
var _a2;
|
||||
if (this.fMap === void 0) {
|
||||
this.fMap = {};
|
||||
const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
|
||||
const fieldsInput = (_a2 = this.info.fields) !== null && _a2 !== void 0 ? _a2 : [];
|
||||
for (const field of fieldsInput) {
|
||||
this.fMap[field.name] = field;
|
||||
this.fMap[field.jsonName] = field;
|
||||
@@ -24589,8 +24589,8 @@ var require_reflection_json_writer = __commonJS({
|
||||
var assert_1 = require_assert();
|
||||
var ReflectionJsonWriter = class {
|
||||
constructor(info3) {
|
||||
var _a;
|
||||
this.fields = (_a = info3.fields) !== null && _a !== void 0 ? _a : [];
|
||||
var _a2;
|
||||
this.fields = (_a2 = info3.fields) !== null && _a2 !== void 0 ? _a2 : [];
|
||||
}
|
||||
/**
|
||||
* Converts the message to a JSON object, based on the field descriptors.
|
||||
@@ -24847,9 +24847,9 @@ var require_reflection_binary_reader = __commonJS({
|
||||
this.info = info3;
|
||||
}
|
||||
prepare() {
|
||||
var _a;
|
||||
var _a2;
|
||||
if (!this.fieldNoToField) {
|
||||
const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
|
||||
const fieldsInput = (_a2 = this.info.fields) !== null && _a2 !== void 0 ? _a2 : [];
|
||||
this.fieldNoToField = new Map(fieldsInput.map((field) => [field.no, field]));
|
||||
}
|
||||
}
|
||||
@@ -25517,9 +25517,9 @@ var require_message_type = __commonJS({
|
||||
* This is equivalent to `JSON.stringify(T.toJson(t))`
|
||||
*/
|
||||
toJsonString(message, options) {
|
||||
var _a;
|
||||
var _a2;
|
||||
let value = this.toJson(message, options);
|
||||
return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
|
||||
return JSON.stringify(value, null, (_a2 = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a2 !== void 0 ? _a2 : 0);
|
||||
}
|
||||
/**
|
||||
* Write the message to binary format.
|
||||
@@ -25845,10 +25845,10 @@ var require_reflection_info2 = __commonJS({
|
||||
exports2.readServiceOption = exports2.readMethodOption = exports2.readMethodOptions = exports2.normalizeMethodInfo = void 0;
|
||||
var runtime_1 = require_commonjs();
|
||||
function normalizeMethodInfo(method, service) {
|
||||
var _a, _b, _c;
|
||||
var _a2, _b, _c;
|
||||
let m = method;
|
||||
m.service = service;
|
||||
m.localName = (_a = m.localName) !== null && _a !== void 0 ? _a : runtime_1.lowerCamelCase(m.name);
|
||||
m.localName = (_a2 = m.localName) !== null && _a2 !== void 0 ? _a2 : runtime_1.lowerCamelCase(m.name);
|
||||
m.serverStreaming = !!m.serverStreaming;
|
||||
m.clientStreaming = !!m.clientStreaming;
|
||||
m.options = (_b = m.options) !== null && _b !== void 0 ? _b : {};
|
||||
@@ -25857,14 +25857,14 @@ var require_reflection_info2 = __commonJS({
|
||||
}
|
||||
exports2.normalizeMethodInfo = normalizeMethodInfo;
|
||||
function readMethodOptions(service, methodName, extensionName, extensionType) {
|
||||
var _a;
|
||||
const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options;
|
||||
var _a2;
|
||||
const options = (_a2 = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a2 === void 0 ? void 0 : _a2.options;
|
||||
return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : void 0;
|
||||
}
|
||||
exports2.readMethodOptions = readMethodOptions;
|
||||
function readMethodOption(service, methodName, extensionName, extensionType) {
|
||||
var _a;
|
||||
const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options;
|
||||
var _a2;
|
||||
const options = (_a2 = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a2 === void 0 ? void 0 : _a2.options;
|
||||
if (!options) {
|
||||
return void 0;
|
||||
}
|
||||
@@ -25953,28 +25953,28 @@ var require_rpc_options = __commonJS({
|
||||
Object.defineProperty(exports2, "__esModule", { value: true });
|
||||
exports2.mergeRpcOptions = void 0;
|
||||
var runtime_1 = require_commonjs();
|
||||
function mergeRpcOptions(defaults, options) {
|
||||
function mergeRpcOptions(defaults2, options) {
|
||||
if (!options)
|
||||
return defaults;
|
||||
return defaults2;
|
||||
let o = {};
|
||||
copy(defaults, o);
|
||||
copy(defaults2, o);
|
||||
copy(options, o);
|
||||
for (let key of Object.keys(options)) {
|
||||
let val = options[key];
|
||||
switch (key) {
|
||||
case "jsonOptions":
|
||||
o.jsonOptions = runtime_1.mergeJsonOptions(defaults.jsonOptions, o.jsonOptions);
|
||||
o.jsonOptions = runtime_1.mergeJsonOptions(defaults2.jsonOptions, o.jsonOptions);
|
||||
break;
|
||||
case "binaryOptions":
|
||||
o.binaryOptions = runtime_1.mergeBinaryOptions(defaults.binaryOptions, o.binaryOptions);
|
||||
o.binaryOptions = runtime_1.mergeBinaryOptions(defaults2.binaryOptions, o.binaryOptions);
|
||||
break;
|
||||
case "meta":
|
||||
o.meta = {};
|
||||
copy(defaults.meta, o.meta);
|
||||
copy(defaults2.meta, o.meta);
|
||||
copy(options.meta, o.meta);
|
||||
break;
|
||||
case "interceptors":
|
||||
o.interceptors = defaults.interceptors ? defaults.interceptors.concat(val) : val.concat();
|
||||
o.interceptors = defaults2.interceptors ? defaults2.interceptors.concat(val) : val.concat();
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -26587,8 +26587,8 @@ var require_test_transport = __commonJS({
|
||||
}
|
||||
// Creates a promise for response headers from the mock data.
|
||||
promiseHeaders() {
|
||||
var _a;
|
||||
const headers = (_a = this.data.headers) !== null && _a !== void 0 ? _a : _TestTransport.defaultHeaders;
|
||||
var _a2;
|
||||
const headers = (_a2 = this.data.headers) !== null && _a2 !== void 0 ? _a2 : _TestTransport.defaultHeaders;
|
||||
return headers instanceof rpc_error_1.RpcError ? Promise.reject(headers) : Promise.resolve(headers);
|
||||
}
|
||||
// Creates a promise for a single, valid, message from the mock data.
|
||||
@@ -26663,14 +26663,14 @@ var require_test_transport = __commonJS({
|
||||
}
|
||||
// Creates a promise for response status from the mock data.
|
||||
promiseStatus() {
|
||||
var _a;
|
||||
const status = (_a = this.data.status) !== null && _a !== void 0 ? _a : _TestTransport.defaultStatus;
|
||||
var _a2;
|
||||
const status = (_a2 = this.data.status) !== null && _a2 !== void 0 ? _a2 : _TestTransport.defaultStatus;
|
||||
return status instanceof rpc_error_1.RpcError ? Promise.reject(status) : Promise.resolve(status);
|
||||
}
|
||||
// Creates a promise for response trailers from the mock data.
|
||||
promiseTrailers() {
|
||||
var _a;
|
||||
const trailers = (_a = this.data.trailers) !== null && _a !== void 0 ? _a : _TestTransport.defaultTrailers;
|
||||
var _a2;
|
||||
const trailers = (_a2 = this.data.trailers) !== null && _a2 !== void 0 ? _a2 : _TestTransport.defaultTrailers;
|
||||
return trailers instanceof rpc_error_1.RpcError ? Promise.reject(trailers) : Promise.resolve(trailers);
|
||||
}
|
||||
maybeSuppressUncaught(...promise) {
|
||||
@@ -26685,8 +26685,8 @@ var require_test_transport = __commonJS({
|
||||
return rpc_options_1.mergeRpcOptions({}, options);
|
||||
}
|
||||
unary(method, input, options) {
|
||||
var _a;
|
||||
const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_) => {
|
||||
var _a2;
|
||||
const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_) => {
|
||||
}).then(delay4(this.responseDelay, options.abort)).then((_) => this.promiseSingleResponse(method)), statusPromise = responsePromise.catch((_) => {
|
||||
}).then(delay4(this.afterResponseDelay, options.abort)).then((_) => this.promiseStatus()), trailersPromise = responsePromise.catch((_) => {
|
||||
}).then(delay4(this.afterResponseDelay, options.abort)).then((_) => this.promiseTrailers());
|
||||
@@ -26695,16 +26695,16 @@ var require_test_transport = __commonJS({
|
||||
return new unary_call_1.UnaryCall(method, requestHeaders, input, headersPromise, responsePromise, statusPromise, trailersPromise);
|
||||
}
|
||||
serverStreaming(method, input, options) {
|
||||
var _a;
|
||||
const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay4(this.responseDelay, options.abort)).catch(() => {
|
||||
var _a2;
|
||||
const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay4(this.responseDelay, options.abort)).catch(() => {
|
||||
}).then(() => this.streamResponses(method, outputStream, options.abort)).then(delay4(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise.then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise.then(() => this.promiseTrailers());
|
||||
this.maybeSuppressUncaught(statusPromise, trailersPromise);
|
||||
this.lastInput = { single: input };
|
||||
return new server_streaming_call_1.ServerStreamingCall(method, requestHeaders, input, headersPromise, outputStream, statusPromise, trailersPromise);
|
||||
}
|
||||
clientStreaming(method, options) {
|
||||
var _a;
|
||||
const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_) => {
|
||||
var _a2;
|
||||
const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_) => {
|
||||
}).then(delay4(this.responseDelay, options.abort)).then((_) => this.promiseSingleResponse(method)), statusPromise = responsePromise.catch((_) => {
|
||||
}).then(delay4(this.afterResponseDelay, options.abort)).then((_) => this.promiseStatus()), trailersPromise = responsePromise.catch((_) => {
|
||||
}).then(delay4(this.afterResponseDelay, options.abort)).then((_) => this.promiseTrailers());
|
||||
@@ -26713,8 +26713,8 @@ var require_test_transport = __commonJS({
|
||||
return new client_streaming_call_1.ClientStreamingCall(method, requestHeaders, this.lastInput, headersPromise, responsePromise, statusPromise, trailersPromise);
|
||||
}
|
||||
duplex(method, options) {
|
||||
var _a;
|
||||
const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay4(this.responseDelay, options.abort)).catch(() => {
|
||||
var _a2;
|
||||
const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay4(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay4(this.responseDelay, options.abort)).catch(() => {
|
||||
}).then(() => this.streamResponses(method, outputStream, options.abort)).then(delay4(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise.then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise.then(() => this.promiseTrailers());
|
||||
this.maybeSuppressUncaught(statusPromise, trailersPromise);
|
||||
this.lastInput = new TestInputStream(this.data, options.abort);
|
||||
@@ -26790,10 +26790,10 @@ var require_rpc_interceptor = __commonJS({
|
||||
exports2.stackDuplexStreamingInterceptors = exports2.stackClientStreamingInterceptors = exports2.stackServerStreamingInterceptors = exports2.stackUnaryInterceptors = exports2.stackIntercept = void 0;
|
||||
var runtime_1 = require_commonjs();
|
||||
function stackIntercept(kind, transport, method, options, input) {
|
||||
var _a, _b, _c, _d;
|
||||
var _a2, _b, _c, _d;
|
||||
if (kind == "unary") {
|
||||
let tail = (mtd, inp, opt) => transport.unary(mtd, inp, opt);
|
||||
for (const curr of ((_a = options.interceptors) !== null && _a !== void 0 ? _a : []).filter((i) => i.interceptUnary).reverse()) {
|
||||
for (const curr of ((_a2 = options.interceptors) !== null && _a2 !== void 0 ? _a2 : []).filter((i) => i.interceptUnary).reverse()) {
|
||||
const next = tail;
|
||||
tail = (mtd, inp, opt) => curr.interceptUnary(next, mtd, inp, opt);
|
||||
}
|
||||
@@ -27094,7 +27094,7 @@ function getProxyUrl(reqUrl) {
|
||||
if (proxyVar) {
|
||||
try {
|
||||
return new DecodedURL(proxyVar);
|
||||
} catch (_a) {
|
||||
} catch (_a2) {
|
||||
if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://"))
|
||||
return new DecodedURL(`http://${proxyVar}`);
|
||||
}
|
||||
@@ -27886,7 +27886,7 @@ var Summary = class {
|
||||
}
|
||||
try {
|
||||
yield access(pathFromEnv, import_fs.constants.R_OK | import_fs.constants.W_OK);
|
||||
} catch (_a) {
|
||||
} catch (_a2) {
|
||||
throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
|
||||
}
|
||||
this._filePath = pathFromEnv;
|
||||
@@ -28902,10 +28902,10 @@ function getState(name) {
|
||||
// node_modules/@actions/cache/lib/cache.js
|
||||
var path10 = __toESM(require("path"), 1);
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-globber.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-globber.js
|
||||
var fs2 = __toESM(require("fs"), 1);
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-glob-options-helper.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-glob-options-helper.js
|
||||
function getOptions(copy) {
|
||||
const result = {
|
||||
followSymbolicLinks: true,
|
||||
@@ -28939,10 +28939,10 @@ function getOptions(copy) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-globber.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-globber.js
|
||||
var path7 = __toESM(require("path"), 1);
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-path-helper.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-path-helper.js
|
||||
var path4 = __toESM(require("path"), 1);
|
||||
var import_assert2 = __toESM(require("assert"), 1);
|
||||
var IS_WINDOWS3 = process.platform === "win32";
|
||||
@@ -29034,16 +29034,16 @@ function safeTrimTrailingSeparator(p) {
|
||||
return p.substr(0, p.length - 1);
|
||||
}
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-match-kind.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-match-kind.js
|
||||
var MatchKind;
|
||||
(function(MatchKind2) {
|
||||
MatchKind2[MatchKind2["None"] = 0] = "None";
|
||||
MatchKind2[MatchKind2["Directory"] = 1] = "Directory";
|
||||
MatchKind2[MatchKind2["File"] = 2] = "File";
|
||||
MatchKind2[MatchKind2["All"] = 3] = "All";
|
||||
(function(MatchKind3) {
|
||||
MatchKind3[MatchKind3["None"] = 0] = "None";
|
||||
MatchKind3[MatchKind3["Directory"] = 1] = "Directory";
|
||||
MatchKind3[MatchKind3["File"] = 2] = "File";
|
||||
MatchKind3[MatchKind3["All"] = 3] = "All";
|
||||
})(MatchKind || (MatchKind = {}));
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-pattern-helper.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-pattern-helper.js
|
||||
var IS_WINDOWS4 = process.platform === "win32";
|
||||
function getSearchPaths(patterns) {
|
||||
patterns = patterns.filter((x) => !x.negate);
|
||||
@@ -29091,13 +29091,13 @@ function partialMatch(patterns, itemPath) {
|
||||
return patterns.some((x) => !x.negate && x.partialMatch(itemPath));
|
||||
}
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-pattern.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-pattern.js
|
||||
var os5 = __toESM(require("os"), 1);
|
||||
var path6 = __toESM(require("path"), 1);
|
||||
var import_assert4 = __toESM(require("assert"), 1);
|
||||
var import_minimatch = __toESM(require_minimatch(), 1);
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-path.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-path.js
|
||||
var path5 = __toESM(require("path"), 1);
|
||||
var import_assert3 = __toESM(require("assert"), 1);
|
||||
var IS_WINDOWS5 = process.platform === "win32";
|
||||
@@ -29159,7 +29159,7 @@ var Path = class {
|
||||
}
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-pattern.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-pattern.js
|
||||
var { Minimatch } = import_minimatch.default;
|
||||
var IS_WINDOWS6 = process.platform === "win32";
|
||||
var Pattern = class _Pattern {
|
||||
@@ -29320,15 +29320,15 @@ var Pattern = class _Pattern {
|
||||
}
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-search-state.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-search-state.js
|
||||
var SearchState = class {
|
||||
constructor(path12, level) {
|
||||
this.path = path12;
|
||||
constructor(path13, level) {
|
||||
this.path = path13;
|
||||
this.level = level;
|
||||
}
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-globber.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-globber.js
|
||||
var __awaiter8 = function(thisArg, _arguments, P, generator) {
|
||||
function adopt(value) {
|
||||
return value instanceof P ? value : new P(function(resolve2) {
|
||||
@@ -29431,10 +29431,10 @@ var DefaultGlobber = class _DefaultGlobber {
|
||||
}
|
||||
glob() {
|
||||
return __awaiter8(this, void 0, void 0, function* () {
|
||||
var _a, e_1, _b, _c;
|
||||
var _a2, e_1, _b, _c;
|
||||
const result = [];
|
||||
try {
|
||||
for (var _d = true, _e = __asyncValues(this.globGenerator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
|
||||
for (var _d = true, _e = __asyncValues(this.globGenerator()), _f; _f = yield _e.next(), _a2 = _f.done, !_a2; _d = true) {
|
||||
_c = _f.value;
|
||||
_d = false;
|
||||
const itemPath = _c;
|
||||
@@ -29444,7 +29444,7 @@ var DefaultGlobber = class _DefaultGlobber {
|
||||
e_1 = { error: e_1_1 };
|
||||
} finally {
|
||||
try {
|
||||
if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
|
||||
if (!_d && !_a2 && (_b = _e.return)) yield _b.call(_e);
|
||||
} finally {
|
||||
if (e_1) throw e_1.error;
|
||||
}
|
||||
@@ -29478,9 +29478,9 @@ var DefaultGlobber = class _DefaultGlobber {
|
||||
const traversalChain = [];
|
||||
while (stack.length) {
|
||||
const item = stack.pop();
|
||||
const match2 = match(patterns, item.path);
|
||||
const partialMatch2 = !!match2 || partialMatch(patterns, item.path);
|
||||
if (!match2 && !partialMatch2) {
|
||||
const match4 = match(patterns, item.path);
|
||||
const partialMatch3 = !!match4 || partialMatch(patterns, item.path);
|
||||
if (!match4 && !partialMatch3) {
|
||||
continue;
|
||||
}
|
||||
const stats = yield __await(
|
||||
@@ -29494,15 +29494,15 @@ var DefaultGlobber = class _DefaultGlobber {
|
||||
continue;
|
||||
}
|
||||
if (stats.isDirectory()) {
|
||||
if (match2 & MatchKind.Directory && options.matchDirectories) {
|
||||
if (match4 & MatchKind.Directory && options.matchDirectories) {
|
||||
yield yield __await(item.path);
|
||||
} else if (!partialMatch2) {
|
||||
} else if (!partialMatch3) {
|
||||
continue;
|
||||
}
|
||||
const childLevel = item.level + 1;
|
||||
const childItems = (yield __await(fs2.promises.readdir(item.path))).map((x) => new SearchState(path7.join(item.path, x), childLevel));
|
||||
stack.push(...childItems.reverse());
|
||||
} else if (match2 & MatchKind.File) {
|
||||
} else if (match4 & MatchKind.File) {
|
||||
yield yield __await(item.path);
|
||||
}
|
||||
}
|
||||
@@ -29565,7 +29565,7 @@ var DefaultGlobber = class _DefaultGlobber {
|
||||
}
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/lib/glob.js
|
||||
// node_modules/@actions/cache/node_modules/@actions/glob/lib/glob.js
|
||||
var __awaiter9 = function(thisArg, _arguments, P, generator) {
|
||||
function adopt(value) {
|
||||
return value instanceof P ? value : new P(function(resolve2) {
|
||||
@@ -29681,11 +29681,11 @@ var __asyncValues2 = function(o) {
|
||||
var versionSalt = "1.0";
|
||||
function createTempDirectory() {
|
||||
return __awaiter10(this, void 0, void 0, function* () {
|
||||
const IS_WINDOWS9 = process.platform === "win32";
|
||||
const IS_WINDOWS14 = process.platform === "win32";
|
||||
let tempDirectory = process.env["RUNNER_TEMP"] || "";
|
||||
if (!tempDirectory) {
|
||||
let baseLocation;
|
||||
if (IS_WINDOWS9) {
|
||||
if (IS_WINDOWS14) {
|
||||
baseLocation = process.env["USERPROFILE"] || "C:\\";
|
||||
} else {
|
||||
if (process.platform === "darwin") {
|
||||
@@ -29706,7 +29706,7 @@ function getArchiveFileSizeInBytes(filePath) {
|
||||
}
|
||||
function resolvePaths(patterns) {
|
||||
return __awaiter10(this, void 0, void 0, function* () {
|
||||
var _a, e_1, _b, _c;
|
||||
var _a2, e_1, _b, _c;
|
||||
var _d;
|
||||
const paths = [];
|
||||
const workspace = (_d = process.env["GITHUB_WORKSPACE"]) !== null && _d !== void 0 ? _d : process.cwd();
|
||||
@@ -29714,7 +29714,7 @@ function resolvePaths(patterns) {
|
||||
implicitDescendants: false
|
||||
});
|
||||
try {
|
||||
for (var _e = true, _f = __asyncValues2(globber.globGenerator()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
|
||||
for (var _e = true, _f = __asyncValues2(globber.globGenerator()), _g; _g = yield _f.next(), _a2 = _g.done, !_a2; _e = true) {
|
||||
_c = _g.value;
|
||||
_e = false;
|
||||
const file = _c;
|
||||
@@ -29730,7 +29730,7 @@ function resolvePaths(patterns) {
|
||||
e_1 = { error: e_1_1 };
|
||||
} finally {
|
||||
try {
|
||||
if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
|
||||
if (!_e && !_a2 && (_b = _f.return)) yield _b.call(_f);
|
||||
} finally {
|
||||
if (e_1) throw e_1.error;
|
||||
}
|
||||
@@ -32519,10 +32519,10 @@ function parseChallenges(challenges) {
|
||||
const challengeRegex = /(\w+)\s+((?:\w+=(?:"[^"]*"|[^,]*),?\s*)+)/g;
|
||||
const paramRegex = /(\w+)="([^"]*)"/g;
|
||||
const parsedChallenges = [];
|
||||
let match2;
|
||||
while ((match2 = challengeRegex.exec(challenges)) !== null) {
|
||||
const scheme = match2[1];
|
||||
const paramsString = match2[2];
|
||||
let match4;
|
||||
while ((match4 = challengeRegex.exec(challenges)) !== null) {
|
||||
const scheme = match4[1];
|
||||
const paramsString = match4[2];
|
||||
const params = {};
|
||||
let paramMatch;
|
||||
while ((paramMatch = paramRegex.exec(paramsString)) !== null) {
|
||||
@@ -32658,7 +32658,7 @@ var SerializerImpl = class {
|
||||
throw new Error(`"${objectName}" with value "${value}" should satisfy the constraint "${constraintName}": ${constraintValue}.`);
|
||||
};
|
||||
if (mapper.constraints && value !== void 0 && value !== null) {
|
||||
const { ExclusiveMaximum, ExclusiveMinimum, InclusiveMaximum, InclusiveMinimum, MaxItems, MaxLength, MinItems, MinLength, MultipleOf, Pattern: Pattern2, UniqueItems } = mapper.constraints;
|
||||
const { ExclusiveMaximum, ExclusiveMinimum, InclusiveMaximum, InclusiveMinimum, MaxItems, MaxLength, MinItems, MinLength, MultipleOf, Pattern: Pattern3, UniqueItems } = mapper.constraints;
|
||||
if (ExclusiveMaximum !== void 0 && value >= ExclusiveMaximum) {
|
||||
failValidation("ExclusiveMaximum", ExclusiveMaximum);
|
||||
}
|
||||
@@ -32686,10 +32686,10 @@ var SerializerImpl = class {
|
||||
if (MultipleOf !== void 0 && value % MultipleOf !== 0) {
|
||||
failValidation("MultipleOf", MultipleOf);
|
||||
}
|
||||
if (Pattern2) {
|
||||
const pattern = typeof Pattern2 === "string" ? new RegExp(Pattern2) : Pattern2;
|
||||
if (Pattern3) {
|
||||
const pattern = typeof Pattern3 === "string" ? new RegExp(Pattern3) : Pattern3;
|
||||
if (typeof value !== "string" || value.match(pattern) === null) {
|
||||
failValidation("Pattern", Pattern2);
|
||||
failValidation("Pattern", Pattern3);
|
||||
}
|
||||
}
|
||||
if (UniqueItems && value.some((item, i, ar) => ar.indexOf(item) !== i)) {
|
||||
@@ -33826,15 +33826,15 @@ function getRequestUrl(baseUri, operationSpec, operationArguments, fallbackObjec
|
||||
let isAbsolutePath = false;
|
||||
let requestUrl = replaceAll(baseUri, urlReplacements);
|
||||
if (operationSpec.path) {
|
||||
let path12 = replaceAll(operationSpec.path, urlReplacements);
|
||||
if (operationSpec.path === "/{nextLink}" && path12.startsWith("/")) {
|
||||
path12 = path12.substring(1);
|
||||
let path13 = replaceAll(operationSpec.path, urlReplacements);
|
||||
if (operationSpec.path === "/{nextLink}" && path13.startsWith("/")) {
|
||||
path13 = path13.substring(1);
|
||||
}
|
||||
if (isAbsoluteUrl(path12)) {
|
||||
requestUrl = path12;
|
||||
if (isAbsoluteUrl(path13)) {
|
||||
requestUrl = path13;
|
||||
isAbsolutePath = true;
|
||||
} else {
|
||||
requestUrl = appendPath(requestUrl, path12);
|
||||
requestUrl = appendPath(requestUrl, path13);
|
||||
}
|
||||
}
|
||||
const { queryParams, sequenceParams } = calculateQueryParameters(operationSpec, operationArguments, fallbackObject);
|
||||
@@ -33880,9 +33880,9 @@ function appendPath(url2, pathToAppend) {
|
||||
}
|
||||
const searchStart = pathToAppend.indexOf("?");
|
||||
if (searchStart !== -1) {
|
||||
const path12 = pathToAppend.substring(0, searchStart);
|
||||
const path13 = pathToAppend.substring(0, searchStart);
|
||||
const search = pathToAppend.substring(searchStart + 1);
|
||||
newPath = newPath + path12;
|
||||
newPath = newPath + path13;
|
||||
if (search) {
|
||||
parsedUrl.search = parsedUrl.search ? `${parsedUrl.search}&${search}` : search;
|
||||
}
|
||||
@@ -34625,22 +34625,22 @@ var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
|
||||
var regexName = new RegExp("^" + nameRegexp + "$");
|
||||
function getAllMatches(string, regex) {
|
||||
const matches = [];
|
||||
let match2 = regex.exec(string);
|
||||
while (match2) {
|
||||
let match4 = regex.exec(string);
|
||||
while (match4) {
|
||||
const allmatches = [];
|
||||
allmatches.startIndex = regex.lastIndex - match2[0].length;
|
||||
const len = match2.length;
|
||||
allmatches.startIndex = regex.lastIndex - match4[0].length;
|
||||
const len = match4.length;
|
||||
for (let index = 0; index < len; index++) {
|
||||
allmatches.push(match2[index]);
|
||||
allmatches.push(match4[index]);
|
||||
}
|
||||
matches.push(allmatches);
|
||||
match2 = regex.exec(string);
|
||||
match4 = regex.exec(string);
|
||||
}
|
||||
return matches;
|
||||
}
|
||||
var isName = function(string) {
|
||||
const match2 = regexName.exec(string);
|
||||
return !(match2 === null || typeof match2 === "undefined");
|
||||
const match4 = regexName.exec(string);
|
||||
return !(match4 === null || typeof match4 === "undefined");
|
||||
};
|
||||
function isExist(v) {
|
||||
return typeof v !== "undefined";
|
||||
@@ -34961,8 +34961,8 @@ function getLineNumberForPosition(xmlData, index) {
|
||||
col: lines[lines.length - 1].length + 1
|
||||
};
|
||||
}
|
||||
function getPositionFromMatch(match2) {
|
||||
return match2.startIndex + match2[1].length;
|
||||
function getPositionFromMatch(match4) {
|
||||
return match4.startIndex + match4[1].length;
|
||||
}
|
||||
|
||||
// node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
|
||||
@@ -35433,11 +35433,11 @@ function toNumber(str, options = {}) {
|
||||
} else if (trimmedStr.includes("e") || trimmedStr.includes("E")) {
|
||||
return resolveEnotation(str, trimmedStr, options);
|
||||
} else {
|
||||
const match2 = numRegex.exec(trimmedStr);
|
||||
if (match2) {
|
||||
const sign = match2[1] || "";
|
||||
const leadingZeros = match2[2];
|
||||
let numTrimmedByZeros = trimZeros(match2[3]);
|
||||
const match4 = numRegex.exec(trimmedStr);
|
||||
if (match4) {
|
||||
const sign = match4[1] || "";
|
||||
const leadingZeros = match4[2];
|
||||
let numTrimmedByZeros = trimZeros(match4[3]);
|
||||
const decimalAdjacentToLeadingZeros = sign ? (
|
||||
// 0., -00., 000.
|
||||
str[leadingZeros.length + 1] === "."
|
||||
@@ -35853,13 +35853,13 @@ var Matcher = class {
|
||||
* @returns {string}
|
||||
*/
|
||||
toString(separator, includeNamespace = true) {
|
||||
const sep7 = separator || this.separator;
|
||||
const sep8 = separator || this.separator;
|
||||
return this.path.map((n) => {
|
||||
if (includeNamespace && n.namespace) {
|
||||
return `${n.namespace}:${n.tag}`;
|
||||
}
|
||||
return n.tag;
|
||||
}).join(sep7);
|
||||
}).join(sep8);
|
||||
}
|
||||
/**
|
||||
* Get path as array of tag names
|
||||
@@ -37479,17 +37479,17 @@ var XML_CHARKEY2 = "_";
|
||||
|
||||
// node_modules/@azure/core-xml/dist/esm/xml.js
|
||||
function getCommonOptions(options) {
|
||||
var _a;
|
||||
var _a2;
|
||||
return {
|
||||
attributesGroupName: XML_ATTRKEY2,
|
||||
textNodeName: (_a = options.xmlCharKey) !== null && _a !== void 0 ? _a : XML_CHARKEY2,
|
||||
textNodeName: (_a2 = options.xmlCharKey) !== null && _a2 !== void 0 ? _a2 : XML_CHARKEY2,
|
||||
ignoreAttributes: false,
|
||||
suppressBooleanAttributes: false
|
||||
};
|
||||
}
|
||||
function getSerializerOptions(options = {}) {
|
||||
var _a, _b;
|
||||
return Object.assign(Object.assign({}, getCommonOptions(options)), { attributeNamePrefix: "@_", format: true, suppressEmptyNode: true, indentBy: "", rootNodeName: (_a = options.rootName) !== null && _a !== void 0 ? _a : "root", cdataPropName: (_b = options.cdataPropName) !== null && _b !== void 0 ? _b : "__cdata" });
|
||||
var _a2, _b;
|
||||
return Object.assign(Object.assign({}, getCommonOptions(options)), { attributeNamePrefix: "@_", format: true, suppressEmptyNode: true, indentBy: "", rootNodeName: (_a2 = options.rootName) !== null && _a2 !== void 0 ? _a2 : "root", cdataPropName: (_b = options.cdataPropName) !== null && _b !== void 0 ? _b : "__cdata" });
|
||||
}
|
||||
function getParserOptions(options = {}) {
|
||||
return Object.assign(Object.assign({}, getCommonOptions(options)), { parseAttributeValue: false, parseTagValue: false, attributeNamePrefix: "", stopNodes: options.stopNodes, processEntities: true, trimValues: false });
|
||||
@@ -38724,9 +38724,9 @@ var StorageSharedKeyCredentialPolicy = class extends CredentialPolicy {
|
||||
* @param request -
|
||||
*/
|
||||
getCanonicalizedResourceString(request) {
|
||||
const path12 = getURLPath(request.url) || "/";
|
||||
const path13 = getURLPath(request.url) || "/";
|
||||
let canonicalizedResourceString = "";
|
||||
canonicalizedResourceString += `/${this.factory.accountName}${path12}`;
|
||||
canonicalizedResourceString += `/${this.factory.accountName}${path13}`;
|
||||
const queries = getURLQueries(request.url);
|
||||
const lowercaseQueries = {};
|
||||
if (queries) {
|
||||
@@ -39216,9 +39216,9 @@ function storageSharedKeyCredentialPolicy(options) {
|
||||
return canonicalizedHeadersStringToSign;
|
||||
}
|
||||
function getCanonicalizedResourceString(request) {
|
||||
const path12 = getURLPath(request.url) || "/";
|
||||
const path13 = getURLPath(request.url) || "/";
|
||||
let canonicalizedResourceString = "";
|
||||
canonicalizedResourceString += `/${options.accountName}${path12}`;
|
||||
canonicalizedResourceString += `/${options.accountName}${path13}`;
|
||||
const queries = getURLQueries(request.url);
|
||||
const lowercaseQueries = {};
|
||||
if (queries) {
|
||||
@@ -52117,8 +52117,8 @@ var PageBlobImpl = class {
|
||||
* aligned and range-end is required.
|
||||
* @param options The options parameters.
|
||||
*/
|
||||
uploadPagesFromURL(sourceUrl2, sourceRange2, contentLength2, range2, options) {
|
||||
return this.client.sendOperationRequest({ sourceUrl: sourceUrl2, sourceRange: sourceRange2, contentLength: contentLength2, range: range2, options }, uploadPagesFromURLOperationSpec);
|
||||
uploadPagesFromURL(sourceUrl2, sourceRange2, contentLength2, range3, options) {
|
||||
return this.client.sendOperationRequest({ sourceUrl: sourceUrl2, sourceRange: sourceRange2, contentLength: contentLength2, range: range3, options }, uploadPagesFromURLOperationSpec);
|
||||
}
|
||||
/**
|
||||
* The Get Page Ranges operation returns the list of valid page ranges for a page blob or snapshot of a
|
||||
@@ -53114,13 +53114,13 @@ var StorageClient = class extends ExtendedServiceClient {
|
||||
if (!options) {
|
||||
options = {};
|
||||
}
|
||||
const defaults = {
|
||||
const defaults2 = {
|
||||
requestContentType: "application/json; charset=utf-8"
|
||||
};
|
||||
const packageDetails = `azsdk-js-azure-storage-blob/12.30.0`;
|
||||
const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}` : `${packageDetails}`;
|
||||
const optionsWithDefaults = {
|
||||
...defaults,
|
||||
...defaults2,
|
||||
...options,
|
||||
userAgentOptions: {
|
||||
userAgentPrefix
|
||||
@@ -53159,10 +53159,10 @@ var StorageContextClient = class extends StorageClient {
|
||||
// node_modules/@azure/storage-blob/dist/esm/utils/utils.common.js
|
||||
function escapeURLPath(url2) {
|
||||
const urlParsed = new URL(url2);
|
||||
let path12 = urlParsed.pathname;
|
||||
path12 = path12 || "/";
|
||||
path12 = escape(path12);
|
||||
urlParsed.pathname = path12;
|
||||
let path13 = urlParsed.pathname;
|
||||
path13 = path13 || "/";
|
||||
path13 = escape(path13);
|
||||
urlParsed.pathname = path13;
|
||||
return urlParsed.toString();
|
||||
}
|
||||
function getProxyUriFromDevConnString(connectionString) {
|
||||
@@ -53247,9 +53247,9 @@ function escape(text) {
|
||||
}
|
||||
function appendToURLPath(url2, name) {
|
||||
const urlParsed = new URL(url2);
|
||||
let path12 = urlParsed.pathname;
|
||||
path12 = path12 ? path12.endsWith("/") ? `${path12}${name}` : `${path12}/${name}` : name;
|
||||
urlParsed.pathname = path12;
|
||||
let path13 = urlParsed.pathname;
|
||||
path13 = path13 ? path13.endsWith("/") ? `${path13}${name}` : `${path13}/${name}` : name;
|
||||
urlParsed.pathname = path13;
|
||||
return urlParsed.toString();
|
||||
}
|
||||
function setURLParameter2(url2, name, value) {
|
||||
@@ -55771,9 +55771,9 @@ var AvroEnumType = class extends AvroType {
|
||||
};
|
||||
var AvroUnionType = class extends AvroType {
|
||||
_types;
|
||||
constructor(types) {
|
||||
constructor(types2) {
|
||||
super();
|
||||
this._types = types;
|
||||
this._types = types2;
|
||||
}
|
||||
async read(stream, options = {}) {
|
||||
const typeIndex = await AvroParser.readInt(stream, options);
|
||||
@@ -59962,10 +59962,10 @@ var UploadProgress = class {
|
||||
};
|
||||
function uploadCacheArchiveSDK(signedUploadURL, archivePath, options) {
|
||||
return __awaiter11(this, void 0, void 0, function* () {
|
||||
var _a;
|
||||
var _a2;
|
||||
const blobClient = new BlobClient(signedUploadURL);
|
||||
const blockBlobClient = blobClient.getBlockBlobClient();
|
||||
const uploadProgress = new UploadProgress((_a = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a !== void 0 ? _a : 0);
|
||||
const uploadProgress = new UploadProgress((_a2 = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a2 !== void 0 ? _a2 : 0);
|
||||
const uploadOptions = {
|
||||
blockSize: options === null || options === void 0 ? void 0 : options.uploadChunkSize,
|
||||
concurrency: options === null || options === void 0 ? void 0 : options.uploadConcurrency,
|
||||
@@ -61297,8 +61297,8 @@ function getCommands(compressionMethod_1, type_1) {
|
||||
});
|
||||
}
|
||||
function getWorkingDirectory() {
|
||||
var _a;
|
||||
return (_a = process.env["GITHUB_WORKSPACE"]) !== null && _a !== void 0 ? _a : process.cwd();
|
||||
var _a2;
|
||||
return (_a2 = process.env["GITHUB_WORKSPACE"]) !== null && _a2 !== void 0 ? _a2 : process.cwd();
|
||||
}
|
||||
function getDecompressionProgram(tarPath, compressionMethod, archivePath) {
|
||||
return __awaiter15(this, void 0, void 0, function* () {
|
||||
@@ -61471,7 +61471,7 @@ function saveCache2(paths_1, key_1, options_1) {
|
||||
}
|
||||
function saveCacheV1(paths_1, key_1, options_1) {
|
||||
return __awaiter16(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
|
||||
var _a, _b, _c, _d, _e, _f;
|
||||
var _a2, _b, _c, _d, _e, _f;
|
||||
const compressionMethod = yield getCompressionMethod();
|
||||
let cacheId = -1;
|
||||
const cachePaths = yield resolvePaths(paths);
|
||||
@@ -61500,7 +61500,7 @@ function saveCacheV1(paths_1, key_1, options_1) {
|
||||
enableCrossOsArchive,
|
||||
cacheSize: archiveFileSize
|
||||
});
|
||||
if ((_a = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _a === void 0 ? void 0 : _a.cacheId) {
|
||||
if ((_a2 = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _a2 === void 0 ? void 0 : _a2.cacheId) {
|
||||
cacheId = (_b = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _b === void 0 ? void 0 : _b.cacheId;
|
||||
} else if ((reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.statusCode) === 400) {
|
||||
throw new Error((_d = (_c = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : `Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the data cap limit, not saving cache.`);
|
||||
@@ -61538,7 +61538,7 @@ function saveCacheV1(paths_1, key_1, options_1) {
|
||||
}
|
||||
function saveCacheV2(paths_1, key_1, options_1) {
|
||||
return __awaiter16(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
|
||||
var _a;
|
||||
var _a2;
|
||||
options = Object.assign(Object.assign({}, options), { uploadChunkSize: 64 * 1024 * 1024, uploadConcurrency: 8, useAzureSdk: true });
|
||||
const compressionMethod = yield getCompressionMethod();
|
||||
const twirpClient = internalCacheTwirpClient();
|
||||
@@ -61578,7 +61578,7 @@ function saveCacheV2(paths_1, key_1, options_1) {
|
||||
signedUploadUrl = response.signedUploadUrl;
|
||||
} catch (error2) {
|
||||
debug(`Failed to reserve cache: ${error2}`);
|
||||
const errorMessage = (_a = error2 === null || error2 === void 0 ? void 0 : error2.message) !== null && _a !== void 0 ? _a : "";
|
||||
const errorMessage = (_a2 = error2 === null || error2 === void 0 ? void 0 : error2.message) !== null && _a2 !== void 0 ? _a2 : "";
|
||||
if (errorMessage.startsWith(CACHE_WRITE_DENIED_PREFIX)) {
|
||||
throw new CacheWriteDeniedError(`Unable to reserve cache with key ${key}. More details: ${errorMessage}`);
|
||||
}
|
||||
@@ -61820,6 +61820,1885 @@ var RANGE_PATTERN = [
|
||||
].join("");
|
||||
var rangeRegex = new RegExp("^" + RANGE_PATTERN + "$", "i");
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-path-helper.js
|
||||
var IS_WINDOWS9 = process.platform === "win32";
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-match-kind.js
|
||||
var MatchKind2;
|
||||
(function(MatchKind3) {
|
||||
MatchKind3[MatchKind3["None"] = 0] = "None";
|
||||
MatchKind3[MatchKind3["Directory"] = 1] = "Directory";
|
||||
MatchKind3[MatchKind3["File"] = 2] = "File";
|
||||
MatchKind3[MatchKind3["All"] = 3] = "All";
|
||||
})(MatchKind2 || (MatchKind2 = {}));
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-pattern-helper.js
|
||||
var IS_WINDOWS10 = process.platform === "win32";
|
||||
|
||||
// node_modules/@actions/glob/node_modules/balanced-match/dist/esm/index.js
|
||||
var balanced = (a, b, str) => {
|
||||
const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
|
||||
const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
|
||||
const r = ma !== null && mb != null && range2(ma, mb, str);
|
||||
return r && {
|
||||
start: r[0],
|
||||
end: r[1],
|
||||
pre: str.slice(0, r[0]),
|
||||
body: str.slice(r[0] + ma.length, r[1]),
|
||||
post: str.slice(r[1] + mb.length)
|
||||
};
|
||||
};
|
||||
var maybeMatch = (reg, str) => {
|
||||
const m = str.match(reg);
|
||||
return m ? m[0] : null;
|
||||
};
|
||||
var range2 = (a, b, str) => {
|
||||
let begs, beg, left, right = void 0, result;
|
||||
let ai = str.indexOf(a);
|
||||
let bi = str.indexOf(b, ai + 1);
|
||||
let i = ai;
|
||||
if (ai >= 0 && bi > 0) {
|
||||
if (a === b) {
|
||||
return [ai, bi];
|
||||
}
|
||||
begs = [];
|
||||
left = str.length;
|
||||
while (i >= 0 && !result) {
|
||||
if (i === ai) {
|
||||
begs.push(i);
|
||||
ai = str.indexOf(a, i + 1);
|
||||
} else if (begs.length === 1) {
|
||||
const r = begs.pop();
|
||||
if (r !== void 0)
|
||||
result = [r, bi];
|
||||
} else {
|
||||
beg = begs.pop();
|
||||
if (beg !== void 0 && beg < left) {
|
||||
left = beg;
|
||||
right = bi;
|
||||
}
|
||||
bi = str.indexOf(b, i + 1);
|
||||
}
|
||||
i = ai < bi && ai >= 0 ? ai : bi;
|
||||
}
|
||||
if (begs.length && right !== void 0) {
|
||||
result = [left, right];
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/node_modules/brace-expansion/dist/esm/index.js
|
||||
var escSlash = "\0SLASH" + Math.random() + "\0";
|
||||
var escOpen = "\0OPEN" + Math.random() + "\0";
|
||||
var escClose = "\0CLOSE" + Math.random() + "\0";
|
||||
var escComma = "\0COMMA" + Math.random() + "\0";
|
||||
var escPeriod = "\0PERIOD" + Math.random() + "\0";
|
||||
var escSlashPattern = new RegExp(escSlash, "g");
|
||||
var escOpenPattern = new RegExp(escOpen, "g");
|
||||
var escClosePattern = new RegExp(escClose, "g");
|
||||
var escCommaPattern = new RegExp(escComma, "g");
|
||||
var escPeriodPattern = new RegExp(escPeriod, "g");
|
||||
var slashPattern = /\\\\/g;
|
||||
var openPattern = /\\{/g;
|
||||
var closePattern = /\\}/g;
|
||||
var commaPattern = /\\,/g;
|
||||
var periodPattern = /\\\./g;
|
||||
var EXPANSION_MAX = 1e5;
|
||||
var EXPANSION_MAX_LENGTH = 4e6;
|
||||
function numeric(str) {
|
||||
return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
|
||||
}
|
||||
function escapeBraces(str) {
|
||||
return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
|
||||
}
|
||||
function unescapeBraces(str) {
|
||||
return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
|
||||
}
|
||||
function parseCommaParts(str) {
|
||||
if (!str) {
|
||||
return [""];
|
||||
}
|
||||
const parts = [];
|
||||
const m = balanced("{", "}", str);
|
||||
if (!m) {
|
||||
return str.split(",");
|
||||
}
|
||||
const { pre, body: body2, post } = m;
|
||||
const p = pre.split(",");
|
||||
p[p.length - 1] += "{" + body2 + "}";
|
||||
const postParts = parseCommaParts(post);
|
||||
if (post.length) {
|
||||
;
|
||||
p[p.length - 1] += postParts.shift();
|
||||
p.push.apply(p, postParts);
|
||||
}
|
||||
parts.push.apply(parts, p);
|
||||
return parts;
|
||||
}
|
||||
function expand(str, options = {}) {
|
||||
if (!str) {
|
||||
return [];
|
||||
}
|
||||
const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH } = options;
|
||||
if (str.slice(0, 2) === "{}") {
|
||||
str = "\\{\\}" + str.slice(2);
|
||||
}
|
||||
return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
|
||||
}
|
||||
function embrace(str) {
|
||||
return "{" + str + "}";
|
||||
}
|
||||
function isPadded(el) {
|
||||
return /^-?0\d/.test(el);
|
||||
}
|
||||
function lte(i, y) {
|
||||
return i <= y;
|
||||
}
|
||||
function gte(i, y) {
|
||||
return i >= y;
|
||||
}
|
||||
function combine(acc, pre, values, max, maxLength, dropEmpties) {
|
||||
const out = [];
|
||||
let length = 0;
|
||||
for (let a = 0; a < acc.length; a++) {
|
||||
for (let v = 0; v < values.length; v++) {
|
||||
if (out.length >= max)
|
||||
return out;
|
||||
const expansion = acc[a] + pre + values[v];
|
||||
if (dropEmpties && !expansion)
|
||||
continue;
|
||||
if (length + expansion.length > maxLength)
|
||||
return out;
|
||||
out.push(expansion);
|
||||
length += expansion.length;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
function expandSequence(body2, isAlphaSequence, max, maxLength) {
|
||||
const n = body2.split(/\.\./);
|
||||
const N = [];
|
||||
if (n[0] === void 0 || n[1] === void 0) {
|
||||
return N;
|
||||
}
|
||||
const x = numeric(n[0]);
|
||||
const y = numeric(n[1]);
|
||||
const width = Math.max(n[0].length, n[1].length);
|
||||
let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
|
||||
let test = lte;
|
||||
const reverse = y < x;
|
||||
if (reverse) {
|
||||
incr *= -1;
|
||||
test = gte;
|
||||
}
|
||||
const pad = n.some(isPadded);
|
||||
let length = 0;
|
||||
for (let i = x; test(i, y) && N.length < max; i += incr) {
|
||||
let c;
|
||||
if (isAlphaSequence) {
|
||||
c = String.fromCharCode(i);
|
||||
if (c === "\\") {
|
||||
c = "";
|
||||
}
|
||||
} else {
|
||||
c = String(i);
|
||||
if (pad) {
|
||||
const need = width - c.length;
|
||||
if (need > 0) {
|
||||
const z = new Array(need + 1).join("0");
|
||||
if (i < 0) {
|
||||
c = "-" + z + c.slice(1);
|
||||
} else {
|
||||
c = z + c;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (length + c.length > maxLength)
|
||||
break;
|
||||
N.push(c);
|
||||
length += c.length;
|
||||
}
|
||||
return N;
|
||||
}
|
||||
function expand_(str, max, maxLength, isTop) {
|
||||
let acc = [""];
|
||||
let dropEmpties = false;
|
||||
let firstGroup = true;
|
||||
for (; ; ) {
|
||||
const m = balanced("{", "}", str);
|
||||
if (!m) {
|
||||
return combine(acc, str, [""], max, maxLength, dropEmpties);
|
||||
}
|
||||
const pre = m.pre;
|
||||
if (/\$$/.test(pre)) {
|
||||
acc = combine(acc, pre + "{" + m.body + "}", [""], max, maxLength, dropEmpties && !m.post.length);
|
||||
firstGroup = false;
|
||||
if (!m.post.length)
|
||||
break;
|
||||
str = m.post;
|
||||
continue;
|
||||
}
|
||||
const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
|
||||
const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
|
||||
const isSequence = isNumericSequence || isAlphaSequence;
|
||||
const isOptions = m.body.indexOf(",") >= 0;
|
||||
if (!isSequence && !isOptions) {
|
||||
if (m.post.match(/,(?!,).*\}/)) {
|
||||
str = m.pre + "{" + m.body + escClose + m.post;
|
||||
isTop = true;
|
||||
continue;
|
||||
}
|
||||
return combine(acc, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties);
|
||||
}
|
||||
if (firstGroup) {
|
||||
dropEmpties = isTop && !isSequence;
|
||||
firstGroup = false;
|
||||
}
|
||||
let values;
|
||||
if (isSequence) {
|
||||
values = expandSequence(m.body, isAlphaSequence, max, maxLength);
|
||||
} else {
|
||||
let n = parseCommaParts(m.body);
|
||||
if (n.length === 1 && n[0] !== void 0) {
|
||||
n = expand_(n[0], max, maxLength, false).map(embrace);
|
||||
if (n.length === 1) {
|
||||
acc = combine(acc, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length);
|
||||
if (!m.post.length)
|
||||
break;
|
||||
str = m.post;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let dropsEmpties = dropEmpties && !m.post.length && !pre;
|
||||
for (let d = 0; dropsEmpties && d < acc.length; d++) {
|
||||
if (acc[d]) {
|
||||
dropsEmpties = false;
|
||||
}
|
||||
}
|
||||
values = [];
|
||||
let valuesLength = 0;
|
||||
outer: for (let j = 0; j < n.length; j++) {
|
||||
const expanded = expand_(n[j], max, maxLength, false);
|
||||
for (let k = 0; k < expanded.length; k++) {
|
||||
const v = expanded[k];
|
||||
if (dropsEmpties && !v)
|
||||
continue;
|
||||
if (values.length >= max || valuesLength + v.length > maxLength) {
|
||||
break outer;
|
||||
}
|
||||
values.push(v);
|
||||
valuesLength += v.length;
|
||||
}
|
||||
}
|
||||
}
|
||||
acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
|
||||
if (!m.post.length)
|
||||
break;
|
||||
str = m.post;
|
||||
}
|
||||
return acc;
|
||||
}
|
||||
|
||||
// node_modules/@actions/glob/node_modules/minimatch/dist/esm/assert-valid-pattern.js
|
||||
var MAX_PATTERN_LENGTH = 1024 * 64;
|
||||
var assertValidPattern = (pattern) => {
|
||||
if (typeof pattern !== "string") {
|
||||
throw new TypeError("invalid pattern");
|
||||
}
|
||||
if (pattern.length > MAX_PATTERN_LENGTH) {
|
||||
throw new TypeError("pattern is too long");
|
||||
}
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/node_modules/minimatch/dist/esm/brace-expressions.js
|
||||
var posixClasses = {
|
||||
"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
|
||||
"[:alpha:]": ["\\p{L}\\p{Nl}", true],
|
||||
"[:ascii:]": ["\\x00-\\x7f", false],
|
||||
"[:blank:]": ["\\p{Zs}\\t", true],
|
||||
"[:cntrl:]": ["\\p{Cc}", true],
|
||||
"[:digit:]": ["\\p{Nd}", true],
|
||||
"[:graph:]": ["\\p{Z}\\p{C}", true, true],
|
||||
"[:lower:]": ["\\p{Ll}", true],
|
||||
"[:print:]": ["\\p{C}", true],
|
||||
"[:punct:]": ["\\p{P}", true],
|
||||
"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
|
||||
"[:upper:]": ["\\p{Lu}", true],
|
||||
"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
|
||||
"[:xdigit:]": ["A-Fa-f0-9", false]
|
||||
};
|
||||
var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
|
||||
var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
||||
var rangesToString = (ranges) => ranges.join("");
|
||||
var parseClass = (glob, position) => {
|
||||
const pos = position;
|
||||
if (glob.charAt(pos) !== "[") {
|
||||
throw new Error("not in a brace expression");
|
||||
}
|
||||
const ranges = [];
|
||||
const negs = [];
|
||||
let i = pos + 1;
|
||||
let sawStart = false;
|
||||
let uflag = false;
|
||||
let escaping = false;
|
||||
let negate = false;
|
||||
let endPos = pos;
|
||||
let rangeStart = "";
|
||||
WHILE: while (i < glob.length) {
|
||||
const c = glob.charAt(i);
|
||||
if ((c === "!" || c === "^") && i === pos + 1) {
|
||||
negate = true;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (c === "]" && sawStart && !escaping) {
|
||||
endPos = i + 1;
|
||||
break;
|
||||
}
|
||||
sawStart = true;
|
||||
if (c === "\\") {
|
||||
if (!escaping) {
|
||||
escaping = true;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (c === "[" && !escaping) {
|
||||
for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
|
||||
if (glob.startsWith(cls, i)) {
|
||||
if (rangeStart) {
|
||||
return ["$.", false, glob.length - pos, true];
|
||||
}
|
||||
i += cls.length;
|
||||
if (neg)
|
||||
negs.push(unip);
|
||||
else
|
||||
ranges.push(unip);
|
||||
uflag = uflag || u;
|
||||
continue WHILE;
|
||||
}
|
||||
}
|
||||
}
|
||||
escaping = false;
|
||||
if (rangeStart) {
|
||||
if (c > rangeStart) {
|
||||
ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
|
||||
} else if (c === rangeStart) {
|
||||
ranges.push(braceEscape(c));
|
||||
}
|
||||
rangeStart = "";
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (glob.startsWith("-]", i + 1)) {
|
||||
ranges.push(braceEscape(c + "-"));
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if (glob.startsWith("-", i + 1)) {
|
||||
rangeStart = c;
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
ranges.push(braceEscape(c));
|
||||
i++;
|
||||
}
|
||||
if (endPos < i) {
|
||||
return ["", false, 0, false];
|
||||
}
|
||||
if (!ranges.length && !negs.length) {
|
||||
return ["$.", false, glob.length - pos, true];
|
||||
}
|
||||
if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
|
||||
const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
|
||||
return [regexpEscape(r), false, endPos - pos, false];
|
||||
}
|
||||
const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
|
||||
const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
|
||||
const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
|
||||
return [comb, uflag, endPos - pos, true];
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/node_modules/minimatch/dist/esm/unescape.js
|
||||
var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
|
||||
if (magicalBraces) {
|
||||
return windowsPathsNoEscape ? s.replace(/\[([^/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1");
|
||||
}
|
||||
return windowsPathsNoEscape ? s.replace(/\[([^/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/node_modules/minimatch/dist/esm/ast.js
|
||||
var _a;
|
||||
var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
|
||||
var isExtglobType = (c) => types.has(c);
|
||||
var isExtglobAST = (c) => isExtglobType(c.type);
|
||||
var adoptionMap = /* @__PURE__ */ new Map([
|
||||
["!", ["@"]],
|
||||
["?", ["?", "@"]],
|
||||
["@", ["@"]],
|
||||
["*", ["*", "+", "?", "@"]],
|
||||
["+", ["+", "@"]]
|
||||
]);
|
||||
var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
|
||||
["!", ["?"]],
|
||||
["@", ["?"]],
|
||||
["+", ["?", "*"]]
|
||||
]);
|
||||
var adoptionAnyMap = /* @__PURE__ */ new Map([
|
||||
["!", ["?", "@"]],
|
||||
["?", ["?", "@"]],
|
||||
["@", ["?", "@"]],
|
||||
["*", ["*", "+", "?", "@"]],
|
||||
["+", ["+", "@", "?", "*"]]
|
||||
]);
|
||||
var usurpMap = /* @__PURE__ */ new Map([
|
||||
["!", /* @__PURE__ */ new Map([["!", "@"]])],
|
||||
[
|
||||
"?",
|
||||
/* @__PURE__ */ new Map([
|
||||
["*", "*"],
|
||||
["+", "*"]
|
||||
])
|
||||
],
|
||||
[
|
||||
"@",
|
||||
/* @__PURE__ */ new Map([
|
||||
["!", "!"],
|
||||
["?", "?"],
|
||||
["@", "@"],
|
||||
["*", "*"],
|
||||
["+", "+"]
|
||||
])
|
||||
],
|
||||
[
|
||||
"+",
|
||||
/* @__PURE__ */ new Map([
|
||||
["?", "*"],
|
||||
["*", "*"]
|
||||
])
|
||||
]
|
||||
]);
|
||||
var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
|
||||
var startNoDot = "(?!\\.)";
|
||||
var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
|
||||
var justDots = /* @__PURE__ */ new Set(["..", "."]);
|
||||
var reSpecials = new Set("().*{}+?[]^$\\!");
|
||||
var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
||||
var qmark = "[^/]";
|
||||
var star = qmark + "*?";
|
||||
var starNoEmpty = qmark + "+?";
|
||||
var ID = 0;
|
||||
var AST = class {
|
||||
type;
|
||||
#root;
|
||||
#hasMagic;
|
||||
#uflag = false;
|
||||
#parts = [];
|
||||
#parent;
|
||||
#parentIndex;
|
||||
#negs;
|
||||
#filledNegs = false;
|
||||
#options;
|
||||
#toString;
|
||||
// set to true if it's an extglob with no children
|
||||
// (which really means one child of '')
|
||||
#emptyExt = false;
|
||||
id = ++ID;
|
||||
get depth() {
|
||||
return (this.#parent?.depth ?? -1) + 1;
|
||||
}
|
||||
[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
|
||||
return {
|
||||
"@@type": "AST",
|
||||
id: this.id,
|
||||
type: this.type,
|
||||
root: this.#root.id,
|
||||
parent: this.#parent?.id,
|
||||
depth: this.depth,
|
||||
partsLength: this.#parts.length,
|
||||
parts: this.#parts
|
||||
};
|
||||
}
|
||||
constructor(type, parent, options = {}) {
|
||||
this.type = type;
|
||||
if (type)
|
||||
this.#hasMagic = true;
|
||||
this.#parent = parent;
|
||||
this.#root = this.#parent ? this.#parent.#root : this;
|
||||
this.#options = this.#root === this ? options : this.#root.#options;
|
||||
this.#negs = this.#root === this ? [] : this.#root.#negs;
|
||||
if (type === "!" && !this.#root.#filledNegs)
|
||||
this.#negs.push(this);
|
||||
this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
|
||||
}
|
||||
get hasMagic() {
|
||||
if (this.#hasMagic !== void 0)
|
||||
return this.#hasMagic;
|
||||
for (const p of this.#parts) {
|
||||
if (typeof p === "string")
|
||||
continue;
|
||||
if (p.type || p.hasMagic)
|
||||
return this.#hasMagic = true;
|
||||
}
|
||||
return this.#hasMagic;
|
||||
}
|
||||
// reconstructs the pattern
|
||||
toString() {
|
||||
return this.#toString !== void 0 ? this.#toString : !this.type ? this.#toString = this.#parts.map((p) => String(p)).join("") : this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
|
||||
}
|
||||
#fillNegs() {
|
||||
if (this !== this.#root)
|
||||
throw new Error("should only call on root");
|
||||
if (this.#filledNegs)
|
||||
return this;
|
||||
this.toString();
|
||||
this.#filledNegs = true;
|
||||
let n;
|
||||
while (n = this.#negs.pop()) {
|
||||
if (n.type !== "!")
|
||||
continue;
|
||||
let p = n;
|
||||
let pp = p.#parent;
|
||||
while (pp) {
|
||||
for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
|
||||
for (const part of n.#parts) {
|
||||
if (typeof part === "string") {
|
||||
throw new Error("string part in extglob AST??");
|
||||
}
|
||||
part.copyIn(pp.#parts[i]);
|
||||
}
|
||||
}
|
||||
p = pp;
|
||||
pp = p.#parent;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
push(...parts) {
|
||||
for (const p of parts) {
|
||||
if (p === "")
|
||||
continue;
|
||||
if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
|
||||
throw new Error("invalid part: " + p);
|
||||
}
|
||||
this.#parts.push(p);
|
||||
}
|
||||
}
|
||||
toJSON() {
|
||||
const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
|
||||
if (this.isStart() && !this.type)
|
||||
ret.unshift([]);
|
||||
if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
|
||||
ret.push({});
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
isStart() {
|
||||
if (this.#root === this)
|
||||
return true;
|
||||
if (!this.#parent?.isStart())
|
||||
return false;
|
||||
if (this.#parentIndex === 0)
|
||||
return true;
|
||||
const p = this.#parent;
|
||||
for (let i = 0; i < this.#parentIndex; i++) {
|
||||
const pp = p.#parts[i];
|
||||
if (!(pp instanceof _a && pp.type === "!")) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
isEnd() {
|
||||
if (this.#root === this)
|
||||
return true;
|
||||
if (this.#parent?.type === "!")
|
||||
return true;
|
||||
if (!this.#parent?.isEnd())
|
||||
return false;
|
||||
if (!this.type)
|
||||
return this.#parent?.isEnd();
|
||||
const pl = this.#parent ? this.#parent.#parts.length : 0;
|
||||
return this.#parentIndex === pl - 1;
|
||||
}
|
||||
copyIn(part) {
|
||||
if (typeof part === "string")
|
||||
this.push(part);
|
||||
else
|
||||
this.push(part.clone(this));
|
||||
}
|
||||
clone(parent) {
|
||||
const c = new _a(this.type, parent);
|
||||
for (const p of this.#parts) {
|
||||
c.copyIn(p);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
static #parseAST(str, ast, pos, opt, extDepth) {
|
||||
const maxDepth = opt.maxExtglobRecursion ?? 2;
|
||||
let escaping = false;
|
||||
let inBrace = false;
|
||||
let braceStart = -1;
|
||||
let braceNeg = false;
|
||||
if (ast.type === null) {
|
||||
let i2 = pos;
|
||||
let acc2 = "";
|
||||
while (i2 < str.length) {
|
||||
const c = str.charAt(i2++);
|
||||
if (escaping || c === "\\") {
|
||||
escaping = !escaping;
|
||||
acc2 += c;
|
||||
continue;
|
||||
}
|
||||
if (inBrace) {
|
||||
if (i2 === braceStart + 1) {
|
||||
if (c === "^" || c === "!") {
|
||||
braceNeg = true;
|
||||
}
|
||||
} else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
|
||||
inBrace = false;
|
||||
}
|
||||
acc2 += c;
|
||||
continue;
|
||||
} else if (c === "[") {
|
||||
inBrace = true;
|
||||
braceStart = i2;
|
||||
braceNeg = false;
|
||||
acc2 += c;
|
||||
continue;
|
||||
}
|
||||
const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
|
||||
if (doRecurse) {
|
||||
ast.push(acc2);
|
||||
acc2 = "";
|
||||
const ext2 = new _a(c, ast);
|
||||
i2 = _a.#parseAST(str, ext2, i2, opt, extDepth + 1);
|
||||
ast.push(ext2);
|
||||
continue;
|
||||
}
|
||||
acc2 += c;
|
||||
}
|
||||
ast.push(acc2);
|
||||
return i2;
|
||||
}
|
||||
let i = pos + 1;
|
||||
let part = new _a(null, ast);
|
||||
const parts = [];
|
||||
let acc = "";
|
||||
while (i < str.length) {
|
||||
const c = str.charAt(i++);
|
||||
if (escaping || c === "\\") {
|
||||
escaping = !escaping;
|
||||
acc += c;
|
||||
continue;
|
||||
}
|
||||
if (inBrace) {
|
||||
if (i === braceStart + 1) {
|
||||
if (c === "^" || c === "!") {
|
||||
braceNeg = true;
|
||||
}
|
||||
} else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
|
||||
inBrace = false;
|
||||
}
|
||||
acc += c;
|
||||
continue;
|
||||
} else if (c === "[") {
|
||||
inBrace = true;
|
||||
braceStart = i;
|
||||
braceNeg = false;
|
||||
acc += c;
|
||||
continue;
|
||||
}
|
||||
const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
|
||||
(extDepth <= maxDepth || ast && ast.#canAdoptType(c));
|
||||
if (doRecurse) {
|
||||
const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
|
||||
part.push(acc);
|
||||
acc = "";
|
||||
const ext2 = new _a(c, part);
|
||||
part.push(ext2);
|
||||
i = _a.#parseAST(str, ext2, i, opt, extDepth + depthAdd);
|
||||
continue;
|
||||
}
|
||||
if (c === "|") {
|
||||
part.push(acc);
|
||||
acc = "";
|
||||
parts.push(part);
|
||||
part = new _a(null, ast);
|
||||
continue;
|
||||
}
|
||||
if (c === ")") {
|
||||
if (acc === "" && ast.#parts.length === 0) {
|
||||
ast.#emptyExt = true;
|
||||
}
|
||||
part.push(acc);
|
||||
acc = "";
|
||||
ast.push(...parts, part);
|
||||
return i;
|
||||
}
|
||||
acc += c;
|
||||
}
|
||||
ast.type = null;
|
||||
ast.#hasMagic = void 0;
|
||||
ast.#parts = [str.substring(pos - 1)];
|
||||
return i;
|
||||
}
|
||||
#canAdoptWithSpace(child2) {
|
||||
return this.#canAdopt(child2, adoptionWithSpaceMap);
|
||||
}
|
||||
#canAdopt(child2, map = adoptionMap) {
|
||||
if (!child2 || typeof child2 !== "object" || child2.type !== null || child2.#parts.length !== 1 || this.type === null) {
|
||||
return false;
|
||||
}
|
||||
const gc = child2.#parts[0];
|
||||
if (!gc || typeof gc !== "object" || gc.type === null) {
|
||||
return false;
|
||||
}
|
||||
return this.#canAdoptType(gc.type, map);
|
||||
}
|
||||
#canAdoptType(c, map = adoptionAnyMap) {
|
||||
return !!map.get(this.type)?.includes(c);
|
||||
}
|
||||
#adoptWithSpace(child2, index) {
|
||||
const gc = child2.#parts[0];
|
||||
const blank = new _a(null, gc, this.options);
|
||||
blank.#parts.push("");
|
||||
gc.push(blank);
|
||||
this.#adopt(child2, index);
|
||||
}
|
||||
#adopt(child2, index) {
|
||||
const gc = child2.#parts[0];
|
||||
this.#parts.splice(index, 1, ...gc.#parts);
|
||||
for (const p of gc.#parts) {
|
||||
if (typeof p === "object")
|
||||
p.#parent = this;
|
||||
}
|
||||
this.#toString = void 0;
|
||||
}
|
||||
#canUsurpType(c) {
|
||||
const m = usurpMap.get(this.type);
|
||||
return !!m?.has(c);
|
||||
}
|
||||
#canUsurp(child2) {
|
||||
if (!child2 || typeof child2 !== "object" || child2.type !== null || child2.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
|
||||
return false;
|
||||
}
|
||||
const gc = child2.#parts[0];
|
||||
if (!gc || typeof gc !== "object" || gc.type === null) {
|
||||
return false;
|
||||
}
|
||||
return this.#canUsurpType(gc.type);
|
||||
}
|
||||
#usurp(child2) {
|
||||
const m = usurpMap.get(this.type);
|
||||
const gc = child2.#parts[0];
|
||||
const nt = m?.get(gc.type);
|
||||
if (!nt)
|
||||
return false;
|
||||
this.#parts = gc.#parts;
|
||||
for (const p of this.#parts) {
|
||||
if (typeof p === "object") {
|
||||
p.#parent = this;
|
||||
}
|
||||
}
|
||||
this.type = nt;
|
||||
this.#toString = void 0;
|
||||
this.#emptyExt = false;
|
||||
}
|
||||
static fromGlob(pattern, options = {}) {
|
||||
const ast = new _a(null, void 0, options);
|
||||
_a.#parseAST(pattern, ast, 0, options, 0);
|
||||
return ast;
|
||||
}
|
||||
// returns the regular expression if there's magic, or the unescaped
|
||||
// string if not.
|
||||
toMMPattern() {
|
||||
if (this !== this.#root)
|
||||
return this.#root.toMMPattern();
|
||||
const glob = this.toString();
|
||||
const [re, body2, hasMagic, uflag] = this.toRegExpSource();
|
||||
const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
|
||||
if (!anyMagic) {
|
||||
return body2;
|
||||
}
|
||||
const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
|
||||
return Object.assign(new RegExp(`^${re}$`, flags), {
|
||||
_src: re,
|
||||
_glob: glob
|
||||
});
|
||||
}
|
||||
get options() {
|
||||
return this.#options;
|
||||
}
|
||||
// returns the string match, the regexp source, whether there's magic
|
||||
// in the regexp (so a regular expression is required) and whether or
|
||||
// not the uflag is needed for the regular expression (for posix classes)
|
||||
// TODO: instead of injecting the start/end at this point, just return
|
||||
// the BODY of the regexp, along with the start/end portions suitable
|
||||
// for binding the start/end in either a joined full-path makeRe context
|
||||
// (where we bind to (^|/), or a standalone matchPart context (where
|
||||
// we bind to ^, and not /). Otherwise slashes get duped!
|
||||
//
|
||||
// In part-matching mode, the start is:
|
||||
// - if not isStart: nothing
|
||||
// - if traversal possible, but not allowed: ^(?!\.\.?$)
|
||||
// - if dots allowed or not possible: ^
|
||||
// - if dots possible and not allowed: ^(?!\.)
|
||||
// end is:
|
||||
// - if not isEnd(): nothing
|
||||
// - else: $
|
||||
//
|
||||
// In full-path matching mode, we put the slash at the START of the
|
||||
// pattern, so start is:
|
||||
// - if first pattern: same as part-matching mode
|
||||
// - if not isStart(): nothing
|
||||
// - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
|
||||
// - if dots allowed or not possible: /
|
||||
// - if dots possible and not allowed: /(?!\.)
|
||||
// end is:
|
||||
// - if last pattern, same as part-matching mode
|
||||
// - else nothing
|
||||
//
|
||||
// Always put the (?:$|/) on negated tails, though, because that has to be
|
||||
// there to bind the end of the negated pattern portion, and it's easier to
|
||||
// just stick it in now rather than try to inject it later in the middle of
|
||||
// the pattern.
|
||||
//
|
||||
// We can just always return the same end, and leave it up to the caller
|
||||
// to know whether it's going to be used joined or in parts.
|
||||
// And, if the start is adjusted slightly, can do the same there:
|
||||
// - if not isStart: nothing
|
||||
// - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
|
||||
// - if dots allowed or not possible: (?:/|^)
|
||||
// - if dots possible and not allowed: (?:/|^)(?!\.)
|
||||
//
|
||||
// But it's better to have a simpler binding without a conditional, for
|
||||
// performance, so probably better to return both start options.
|
||||
//
|
||||
// Then the caller just ignores the end if it's not the first pattern,
|
||||
// and the start always gets applied.
|
||||
//
|
||||
// But that's always going to be $ if it's the ending pattern, or nothing,
|
||||
// so the caller can just attach $ at the end of the pattern when building.
|
||||
//
|
||||
// So the todo is:
|
||||
// - better detect what kind of start is needed
|
||||
// - return both flavors of starting pattern
|
||||
// - attach $ at the end of the pattern when creating the actual RegExp
|
||||
//
|
||||
// Ah, but wait, no, that all only applies to the root when the first pattern
|
||||
// is not an extglob. If the first pattern IS an extglob, then we need all
|
||||
// that dot prevention biz to live in the extglob portions, because eg
|
||||
// +(*|.x*) can match .xy but not .yx.
|
||||
//
|
||||
// So, return the two flavors if it's #root and the first child is not an
|
||||
// AST, otherwise leave it to the child AST to handle it, and there,
|
||||
// use the (?:^|/) style of start binding.
|
||||
//
|
||||
// Even simplified further:
|
||||
// - Since the start for a join is eg /(?!\.) and the start for a part
|
||||
// is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
|
||||
// or start or whatever) and prepend ^ or / at the Regexp construction.
|
||||
toRegExpSource(allowDot) {
|
||||
const dot = allowDot ?? !!this.#options.dot;
|
||||
if (this.#root === this) {
|
||||
this.#flatten();
|
||||
this.#fillNegs();
|
||||
}
|
||||
if (!isExtglobAST(this)) {
|
||||
const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
|
||||
const src = this.#parts.map((p) => {
|
||||
const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
|
||||
this.#hasMagic = this.#hasMagic || hasMagic;
|
||||
this.#uflag = this.#uflag || uflag;
|
||||
return re;
|
||||
}).join("");
|
||||
let start2 = "";
|
||||
if (this.isStart()) {
|
||||
if (typeof this.#parts[0] === "string") {
|
||||
const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
|
||||
if (!dotTravAllowed) {
|
||||
const aps = addPatternStart;
|
||||
const needNoTrav = (
|
||||
// dots are allowed, and the pattern starts with [ or .
|
||||
dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
|
||||
src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
|
||||
src.startsWith("\\.\\.") && aps.has(src.charAt(4))
|
||||
);
|
||||
const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
|
||||
start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
|
||||
}
|
||||
}
|
||||
}
|
||||
let end = "";
|
||||
if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
|
||||
end = "(?:$|\\/)";
|
||||
}
|
||||
const final2 = start2 + src + end;
|
||||
return [
|
||||
final2,
|
||||
unescape(src),
|
||||
this.#hasMagic = !!this.#hasMagic,
|
||||
this.#uflag
|
||||
];
|
||||
}
|
||||
const repeated = this.type === "*" || this.type === "+";
|
||||
const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
|
||||
let body2 = this.#partsToRegExp(dot);
|
||||
if (this.isStart() && this.isEnd() && !body2 && this.type !== "!") {
|
||||
const s = this.toString();
|
||||
const me = this;
|
||||
me.#parts = [s];
|
||||
me.type = null;
|
||||
me.#hasMagic = void 0;
|
||||
return [s, unescape(this.toString()), false, false];
|
||||
}
|
||||
let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
|
||||
if (bodyDotAllowed === body2) {
|
||||
bodyDotAllowed = "";
|
||||
}
|
||||
if (bodyDotAllowed) {
|
||||
body2 = `(?:${body2})(?:${bodyDotAllowed})*?`;
|
||||
}
|
||||
let final = "";
|
||||
if (this.type === "!" && this.#emptyExt) {
|
||||
final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
|
||||
} else {
|
||||
const close = this.type === "!" ? (
|
||||
// !() must match something,but !(x) can match ''
|
||||
"))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
|
||||
) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
|
||||
final = start + body2 + close;
|
||||
}
|
||||
return [
|
||||
final,
|
||||
unescape(body2),
|
||||
this.#hasMagic = !!this.#hasMagic,
|
||||
this.#uflag
|
||||
];
|
||||
}
|
||||
#flatten() {
|
||||
if (!isExtglobAST(this)) {
|
||||
for (const p of this.#parts) {
|
||||
if (typeof p === "object") {
|
||||
p.#flatten();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let iterations = 0;
|
||||
let done = false;
|
||||
do {
|
||||
done = true;
|
||||
for (let i = 0; i < this.#parts.length; i++) {
|
||||
const c = this.#parts[i];
|
||||
if (typeof c === "object") {
|
||||
c.#flatten();
|
||||
if (this.#canAdopt(c)) {
|
||||
done = false;
|
||||
this.#adopt(c, i);
|
||||
} else if (this.#canAdoptWithSpace(c)) {
|
||||
done = false;
|
||||
this.#adoptWithSpace(c, i);
|
||||
} else if (this.#canUsurp(c)) {
|
||||
done = false;
|
||||
this.#usurp(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
} while (!done && ++iterations < 10);
|
||||
}
|
||||
this.#toString = void 0;
|
||||
}
|
||||
#partsToRegExp(dot) {
|
||||
return this.#parts.map((p) => {
|
||||
if (typeof p === "string") {
|
||||
throw new Error("string type in extglob ast??");
|
||||
}
|
||||
const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
|
||||
this.#uflag = this.#uflag || uflag;
|
||||
return re;
|
||||
}).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
|
||||
}
|
||||
static #parseGlob(glob, hasMagic, noEmpty = false) {
|
||||
let escaping = false;
|
||||
let re = "";
|
||||
let uflag = false;
|
||||
let inStar = false;
|
||||
for (let i = 0; i < glob.length; i++) {
|
||||
const c = glob.charAt(i);
|
||||
if (escaping) {
|
||||
escaping = false;
|
||||
re += (reSpecials.has(c) ? "\\" : "") + c;
|
||||
continue;
|
||||
}
|
||||
if (c === "*") {
|
||||
if (inStar)
|
||||
continue;
|
||||
inStar = true;
|
||||
re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
|
||||
hasMagic = true;
|
||||
continue;
|
||||
} else {
|
||||
inStar = false;
|
||||
}
|
||||
if (c === "\\") {
|
||||
if (i === glob.length - 1) {
|
||||
re += "\\\\";
|
||||
} else {
|
||||
escaping = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (c === "[") {
|
||||
const [src, needUflag, consumed, magic] = parseClass(glob, i);
|
||||
if (consumed) {
|
||||
re += src;
|
||||
uflag = uflag || needUflag;
|
||||
i += consumed - 1;
|
||||
hasMagic = hasMagic || magic;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (c === "?") {
|
||||
re += qmark;
|
||||
hasMagic = true;
|
||||
continue;
|
||||
}
|
||||
re += regExpEscape(c);
|
||||
}
|
||||
return [re, unescape(glob), !!hasMagic, uflag];
|
||||
}
|
||||
};
|
||||
_a = AST;
|
||||
|
||||
// node_modules/@actions/glob/node_modules/minimatch/dist/esm/escape.js
|
||||
var escape2 = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
|
||||
if (magicalBraces) {
|
||||
return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
|
||||
}
|
||||
return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
|
||||
};
|
||||
|
||||
// node_modules/@actions/glob/node_modules/minimatch/dist/esm/index.js
|
||||
var minimatch2 = (p, pattern, options = {}) => {
|
||||
assertValidPattern(pattern);
|
||||
if (!options.nocomment && pattern.charAt(0) === "#") {
|
||||
return false;
|
||||
}
|
||||
return new Minimatch2(pattern, options).match(p);
|
||||
};
|
||||
var starDotExtRE = /^\*+([^+@!?*[(]*)$/;
|
||||
var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
|
||||
var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
|
||||
var starDotExtTestNocase = (ext2) => {
|
||||
ext2 = ext2.toLowerCase();
|
||||
return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
|
||||
};
|
||||
var starDotExtTestNocaseDot = (ext2) => {
|
||||
ext2 = ext2.toLowerCase();
|
||||
return (f) => f.toLowerCase().endsWith(ext2);
|
||||
};
|
||||
var starDotStarRE = /^\*+\.\*+$/;
|
||||
var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
|
||||
var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
|
||||
var dotStarRE = /^\.\*+$/;
|
||||
var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
|
||||
var starRE = /^\*+$/;
|
||||
var starTest = (f) => f.length !== 0 && !f.startsWith(".");
|
||||
var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
|
||||
var qmarksRE = /^\?+([^+@!?*[(]*)?$/;
|
||||
var qmarksTestNocase = ([$0, ext2 = ""]) => {
|
||||
const noext = qmarksTestNoExt([$0]);
|
||||
if (!ext2)
|
||||
return noext;
|
||||
ext2 = ext2.toLowerCase();
|
||||
return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
|
||||
};
|
||||
var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
|
||||
const noext = qmarksTestNoExtDot([$0]);
|
||||
if (!ext2)
|
||||
return noext;
|
||||
ext2 = ext2.toLowerCase();
|
||||
return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
|
||||
};
|
||||
var qmarksTestDot = ([$0, ext2 = ""]) => {
|
||||
const noext = qmarksTestNoExtDot([$0]);
|
||||
return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
|
||||
};
|
||||
var qmarksTest = ([$0, ext2 = ""]) => {
|
||||
const noext = qmarksTestNoExt([$0]);
|
||||
return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
|
||||
};
|
||||
var qmarksTestNoExt = ([$0]) => {
|
||||
const len = $0.length;
|
||||
return (f) => f.length === len && !f.startsWith(".");
|
||||
};
|
||||
var qmarksTestNoExtDot = ([$0]) => {
|
||||
const len = $0.length;
|
||||
return (f) => f.length === len && f !== "." && f !== "..";
|
||||
};
|
||||
var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
|
||||
var path11 = {
|
||||
win32: { sep: "\\" },
|
||||
posix: { sep: "/" }
|
||||
};
|
||||
var sep7 = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
|
||||
minimatch2.sep = sep7;
|
||||
var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
|
||||
minimatch2.GLOBSTAR = GLOBSTAR;
|
||||
var qmark2 = "[^/]";
|
||||
var star2 = qmark2 + "*?";
|
||||
var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
|
||||
var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
|
||||
var filter2 = (pattern, options = {}) => (p) => minimatch2(p, pattern, options);
|
||||
minimatch2.filter = filter2;
|
||||
var ext = (a, b = {}) => Object.assign({}, a, b);
|
||||
var defaults = (def) => {
|
||||
if (!def || typeof def !== "object" || !Object.keys(def).length) {
|
||||
return minimatch2;
|
||||
}
|
||||
const orig = minimatch2;
|
||||
const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
|
||||
return Object.assign(m, {
|
||||
Minimatch: class Minimatch extends orig.Minimatch {
|
||||
constructor(pattern, options = {}) {
|
||||
super(pattern, ext(def, options));
|
||||
}
|
||||
static defaults(options) {
|
||||
return orig.defaults(ext(def, options)).Minimatch;
|
||||
}
|
||||
},
|
||||
AST: class AST extends orig.AST {
|
||||
/* c8 ignore start */
|
||||
constructor(type, parent, options = {}) {
|
||||
super(type, parent, ext(def, options));
|
||||
}
|
||||
/* c8 ignore stop */
|
||||
static fromGlob(pattern, options = {}) {
|
||||
return orig.AST.fromGlob(pattern, ext(def, options));
|
||||
}
|
||||
},
|
||||
unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
|
||||
escape: (s, options = {}) => orig.escape(s, ext(def, options)),
|
||||
filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
|
||||
defaults: (options) => orig.defaults(ext(def, options)),
|
||||
makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
|
||||
braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
|
||||
match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
|
||||
sep: orig.sep,
|
||||
GLOBSTAR
|
||||
});
|
||||
};
|
||||
minimatch2.defaults = defaults;
|
||||
var braceExpand = (pattern, options = {}) => {
|
||||
assertValidPattern(pattern);
|
||||
if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
|
||||
return [pattern];
|
||||
}
|
||||
return expand(pattern, { max: options.braceExpandMax });
|
||||
};
|
||||
minimatch2.braceExpand = braceExpand;
|
||||
var makeRe = (pattern, options = {}) => new Minimatch2(pattern, options).makeRe();
|
||||
minimatch2.makeRe = makeRe;
|
||||
var match2 = (list, pattern, options = {}) => {
|
||||
const mm = new Minimatch2(pattern, options);
|
||||
list = list.filter((f) => mm.match(f));
|
||||
if (mm.options.nonull && !list.length) {
|
||||
list.push(pattern);
|
||||
}
|
||||
return list;
|
||||
};
|
||||
minimatch2.match = match2;
|
||||
var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
|
||||
var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
||||
var Minimatch2 = class {
|
||||
options;
|
||||
set;
|
||||
pattern;
|
||||
windowsPathsNoEscape;
|
||||
nonegate;
|
||||
negate;
|
||||
comment;
|
||||
empty;
|
||||
preserveMultipleSlashes;
|
||||
partial;
|
||||
globSet;
|
||||
globParts;
|
||||
nocase;
|
||||
isWindows;
|
||||
platform;
|
||||
windowsNoMagicRoot;
|
||||
maxGlobstarRecursion;
|
||||
regexp;
|
||||
constructor(pattern, options = {}) {
|
||||
assertValidPattern(pattern);
|
||||
options = options || {};
|
||||
this.options = options;
|
||||
this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
|
||||
this.pattern = pattern;
|
||||
this.platform = options.platform || defaultPlatform;
|
||||
this.isWindows = this.platform === "win32";
|
||||
const awe = "allowWindowsEscape";
|
||||
this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
|
||||
if (this.windowsPathsNoEscape) {
|
||||
this.pattern = this.pattern.replace(/\\/g, "/");
|
||||
}
|
||||
this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
|
||||
this.regexp = null;
|
||||
this.negate = false;
|
||||
this.nonegate = !!options.nonegate;
|
||||
this.comment = false;
|
||||
this.empty = false;
|
||||
this.partial = !!options.partial;
|
||||
this.nocase = !!this.options.nocase;
|
||||
this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
|
||||
this.globSet = [];
|
||||
this.globParts = [];
|
||||
this.set = [];
|
||||
this.make();
|
||||
}
|
||||
hasMagic() {
|
||||
if (this.options.magicalBraces && this.set.length > 1) {
|
||||
return true;
|
||||
}
|
||||
for (const pattern of this.set) {
|
||||
for (const part of pattern) {
|
||||
if (typeof part !== "string")
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
debug(..._) {
|
||||
}
|
||||
make() {
|
||||
const pattern = this.pattern;
|
||||
const options = this.options;
|
||||
if (!options.nocomment && pattern.charAt(0) === "#") {
|
||||
this.comment = true;
|
||||
return;
|
||||
}
|
||||
if (!pattern) {
|
||||
this.empty = true;
|
||||
return;
|
||||
}
|
||||
this.parseNegate();
|
||||
this.globSet = [...new Set(this.braceExpand())];
|
||||
if (options.debug) {
|
||||
this.debug = (...args) => console.error(...args);
|
||||
}
|
||||
this.debug(this.pattern, this.globSet);
|
||||
const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
|
||||
this.globParts = this.preprocess(rawGlobParts);
|
||||
this.debug(this.pattern, this.globParts);
|
||||
let set = this.globParts.map((s, _, __) => {
|
||||
if (this.isWindows && this.windowsNoMagicRoot) {
|
||||
const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
|
||||
const isDrive = /^[a-z]:/i.test(s[0]);
|
||||
if (isUNC) {
|
||||
return [
|
||||
...s.slice(0, 4),
|
||||
...s.slice(4).map((ss) => this.parse(ss))
|
||||
];
|
||||
} else if (isDrive) {
|
||||
return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
|
||||
}
|
||||
}
|
||||
return s.map((ss) => this.parse(ss));
|
||||
});
|
||||
this.debug(this.pattern, set);
|
||||
this.set = set.filter((s) => s.indexOf(false) === -1);
|
||||
if (this.isWindows) {
|
||||
for (let i = 0; i < this.set.length; i++) {
|
||||
const p = this.set[i];
|
||||
if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
|
||||
p[2] = "?";
|
||||
}
|
||||
}
|
||||
}
|
||||
this.debug(this.pattern, this.set);
|
||||
}
|
||||
// various transforms to equivalent pattern sets that are
|
||||
// faster to process in a filesystem walk. The goal is to
|
||||
// eliminate what we can, and push all ** patterns as far
|
||||
// to the right as possible, even if it increases the number
|
||||
// of patterns that we have to process.
|
||||
preprocess(globParts) {
|
||||
if (this.options.noglobstar) {
|
||||
for (const partset of globParts) {
|
||||
for (let j = 0; j < partset.length; j++) {
|
||||
if (partset[j] === "**") {
|
||||
partset[j] = "*";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const { optimizationLevel = 1 } = this.options;
|
||||
if (optimizationLevel >= 2) {
|
||||
globParts = this.firstPhasePreProcess(globParts);
|
||||
globParts = this.secondPhasePreProcess(globParts);
|
||||
} else if (optimizationLevel >= 1) {
|
||||
globParts = this.levelOneOptimize(globParts);
|
||||
} else {
|
||||
globParts = this.adjascentGlobstarOptimize(globParts);
|
||||
}
|
||||
return globParts;
|
||||
}
|
||||
// just get rid of adjascent ** portions
|
||||
adjascentGlobstarOptimize(globParts) {
|
||||
return globParts.map((parts) => {
|
||||
let gs = -1;
|
||||
while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
|
||||
let i = gs;
|
||||
while (parts[i + 1] === "**") {
|
||||
i++;
|
||||
}
|
||||
if (i !== gs) {
|
||||
parts.splice(gs, i - gs);
|
||||
}
|
||||
}
|
||||
return parts;
|
||||
});
|
||||
}
|
||||
// get rid of adjascent ** and resolve .. portions
|
||||
levelOneOptimize(globParts) {
|
||||
return globParts.map((parts) => {
|
||||
parts = parts.reduce((set, part) => {
|
||||
const prev = set[set.length - 1];
|
||||
if (part === "**" && prev === "**") {
|
||||
return set;
|
||||
}
|
||||
if (part === "..") {
|
||||
if (prev && prev !== ".." && prev !== "." && prev !== "**") {
|
||||
set.pop();
|
||||
return set;
|
||||
}
|
||||
}
|
||||
set.push(part);
|
||||
return set;
|
||||
}, []);
|
||||
return parts.length === 0 ? [""] : parts;
|
||||
});
|
||||
}
|
||||
levelTwoFileOptimize(parts) {
|
||||
if (!Array.isArray(parts)) {
|
||||
parts = this.slashSplit(parts);
|
||||
}
|
||||
let didSomething = false;
|
||||
do {
|
||||
didSomething = false;
|
||||
if (!this.preserveMultipleSlashes) {
|
||||
for (let i = 1; i < parts.length - 1; i++) {
|
||||
const p = parts[i];
|
||||
if (i === 1 && p === "" && parts[0] === "")
|
||||
continue;
|
||||
if (p === "." || p === "") {
|
||||
didSomething = true;
|
||||
parts.splice(i, 1);
|
||||
i--;
|
||||
}
|
||||
}
|
||||
if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
|
||||
didSomething = true;
|
||||
parts.pop();
|
||||
}
|
||||
}
|
||||
let dd = 0;
|
||||
while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
|
||||
const p = parts[dd - 1];
|
||||
if (p && p !== "." && p !== ".." && p !== "**" && !(this.isWindows && /^[a-z]:$/i.test(p))) {
|
||||
didSomething = true;
|
||||
parts.splice(dd - 1, 2);
|
||||
dd -= 2;
|
||||
}
|
||||
}
|
||||
} while (didSomething);
|
||||
return parts.length === 0 ? [""] : parts;
|
||||
}
|
||||
// First phase: single-pattern processing
|
||||
// <pre> is 1 or more portions
|
||||
// <rest> is 1 or more portions
|
||||
// <p> is any portion other than ., .., '', or **
|
||||
// <e> is . or ''
|
||||
//
|
||||
// **/.. is *brutal* for filesystem walking performance, because
|
||||
// it effectively resets the recursive walk each time it occurs,
|
||||
// and ** cannot be reduced out by a .. pattern part like a regexp
|
||||
// or most strings (other than .., ., and '') can be.
|
||||
//
|
||||
// <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
|
||||
// <pre>/<e>/<rest> -> <pre>/<rest>
|
||||
// <pre>/<p>/../<rest> -> <pre>/<rest>
|
||||
// **/**/<rest> -> **/<rest>
|
||||
//
|
||||
// **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
|
||||
// this WOULD be allowed if ** did follow symlinks, or * didn't
|
||||
firstPhasePreProcess(globParts) {
|
||||
let didSomething = false;
|
||||
do {
|
||||
didSomething = false;
|
||||
for (let parts of globParts) {
|
||||
let gs = -1;
|
||||
while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
|
||||
let gss = gs;
|
||||
while (parts[gss + 1] === "**") {
|
||||
gss++;
|
||||
}
|
||||
if (gss > gs) {
|
||||
parts.splice(gs + 1, gss - gs);
|
||||
}
|
||||
let next = parts[gs + 1];
|
||||
const p = parts[gs + 2];
|
||||
const p2 = parts[gs + 3];
|
||||
if (next !== "..")
|
||||
continue;
|
||||
if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
|
||||
continue;
|
||||
}
|
||||
didSomething = true;
|
||||
parts.splice(gs, 1);
|
||||
const other = parts.slice(0);
|
||||
other[gs] = "**";
|
||||
globParts.push(other);
|
||||
gs--;
|
||||
}
|
||||
if (!this.preserveMultipleSlashes) {
|
||||
for (let i = 1; i < parts.length - 1; i++) {
|
||||
const p = parts[i];
|
||||
if (i === 1 && p === "" && parts[0] === "")
|
||||
continue;
|
||||
if (p === "." || p === "") {
|
||||
didSomething = true;
|
||||
parts.splice(i, 1);
|
||||
i--;
|
||||
}
|
||||
}
|
||||
if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
|
||||
didSomething = true;
|
||||
parts.pop();
|
||||
}
|
||||
}
|
||||
let dd = 0;
|
||||
while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
|
||||
const p = parts[dd - 1];
|
||||
if (p && p !== "." && p !== ".." && p !== "**") {
|
||||
didSomething = true;
|
||||
const needDot = dd === 1 && parts[dd + 1] === "**";
|
||||
const splin = needDot ? ["."] : [];
|
||||
parts.splice(dd - 1, 2, ...splin);
|
||||
if (parts.length === 0)
|
||||
parts.push("");
|
||||
dd -= 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
} while (didSomething);
|
||||
return globParts;
|
||||
}
|
||||
// second phase: multi-pattern dedupes
|
||||
// {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
|
||||
// {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
|
||||
// {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
|
||||
//
|
||||
// {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
|
||||
// ^-- not valid because ** doens't follow symlinks
|
||||
secondPhasePreProcess(globParts) {
|
||||
for (let i = 0; i < globParts.length - 1; i++) {
|
||||
for (let j = i + 1; j < globParts.length; j++) {
|
||||
const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
|
||||
if (matched) {
|
||||
globParts[i] = [];
|
||||
globParts[j] = matched;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return globParts.filter((gs) => gs.length);
|
||||
}
|
||||
partsMatch(a, b, emptyGSMatch = false) {
|
||||
let ai = 0;
|
||||
let bi = 0;
|
||||
let result = [];
|
||||
let which2 = "";
|
||||
while (ai < a.length && bi < b.length) {
|
||||
if (a[ai] === b[bi]) {
|
||||
result.push(which2 === "b" ? b[bi] : a[ai]);
|
||||
ai++;
|
||||
bi++;
|
||||
} else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
|
||||
result.push(a[ai]);
|
||||
ai++;
|
||||
} else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
|
||||
result.push(b[bi]);
|
||||
bi++;
|
||||
} else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
|
||||
if (which2 === "b")
|
||||
return false;
|
||||
which2 = "a";
|
||||
result.push(a[ai]);
|
||||
ai++;
|
||||
bi++;
|
||||
} else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
|
||||
if (which2 === "a")
|
||||
return false;
|
||||
which2 = "b";
|
||||
result.push(b[bi]);
|
||||
ai++;
|
||||
bi++;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return a.length === b.length && result;
|
||||
}
|
||||
parseNegate() {
|
||||
if (this.nonegate)
|
||||
return;
|
||||
const pattern = this.pattern;
|
||||
let negate = false;
|
||||
let negateOffset = 0;
|
||||
for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
|
||||
negate = !negate;
|
||||
negateOffset++;
|
||||
}
|
||||
if (negateOffset)
|
||||
this.pattern = pattern.slice(negateOffset);
|
||||
this.negate = negate;
|
||||
}
|
||||
// set partial to true to test if, for example,
|
||||
// "/a/b" matches the start of "/*/b/*/d"
|
||||
// Partial means, if you run out of file before you run
|
||||
// out of pattern, then that's fine, as long as all
|
||||
// the parts match.
|
||||
matchOne(file, pattern, partial = false) {
|
||||
let fileStartIndex = 0;
|
||||
let patternStartIndex = 0;
|
||||
if (this.isWindows) {
|
||||
const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
|
||||
const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
|
||||
const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
|
||||
const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
|
||||
const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
|
||||
const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
|
||||
if (typeof fdi === "number" && typeof pdi === "number") {
|
||||
const [fd, pd] = [
|
||||
file[fdi],
|
||||
pattern[pdi]
|
||||
];
|
||||
if (fd.toLowerCase() === pd.toLowerCase()) {
|
||||
pattern[pdi] = fd;
|
||||
patternStartIndex = pdi;
|
||||
fileStartIndex = fdi;
|
||||
}
|
||||
}
|
||||
}
|
||||
const { optimizationLevel = 1 } = this.options;
|
||||
if (optimizationLevel >= 2) {
|
||||
file = this.levelTwoFileOptimize(file);
|
||||
}
|
||||
if (pattern.includes(GLOBSTAR)) {
|
||||
return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
|
||||
}
|
||||
return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
|
||||
}
|
||||
#matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
|
||||
const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
|
||||
const lastgs = pattern.lastIndexOf(GLOBSTAR);
|
||||
const [head, body2, tail] = partial ? [
|
||||
pattern.slice(patternIndex, firstgs),
|
||||
pattern.slice(firstgs + 1),
|
||||
[]
|
||||
] : [
|
||||
pattern.slice(patternIndex, firstgs),
|
||||
pattern.slice(firstgs + 1, lastgs),
|
||||
pattern.slice(lastgs + 1)
|
||||
];
|
||||
if (head.length) {
|
||||
const fileHead = file.slice(fileIndex, fileIndex + head.length);
|
||||
if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
|
||||
return false;
|
||||
}
|
||||
fileIndex += head.length;
|
||||
patternIndex += head.length;
|
||||
}
|
||||
let fileTailMatch = 0;
|
||||
if (tail.length) {
|
||||
if (tail.length + fileIndex > file.length)
|
||||
return false;
|
||||
let tailStart = file.length - tail.length;
|
||||
if (this.#matchOne(file, tail, partial, tailStart, 0)) {
|
||||
fileTailMatch = tail.length;
|
||||
} else {
|
||||
if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
|
||||
return false;
|
||||
}
|
||||
tailStart--;
|
||||
if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
|
||||
return false;
|
||||
}
|
||||
fileTailMatch = tail.length + 1;
|
||||
}
|
||||
}
|
||||
if (!body2.length) {
|
||||
let sawSome = !!fileTailMatch;
|
||||
for (let i2 = fileIndex; i2 < file.length - fileTailMatch; i2++) {
|
||||
const f = String(file[i2]);
|
||||
sawSome = true;
|
||||
if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return partial || sawSome;
|
||||
}
|
||||
const bodySegments = [[[], 0]];
|
||||
let currentBody = bodySegments[0];
|
||||
let nonGsParts = 0;
|
||||
const nonGsPartsSums = [0];
|
||||
for (const b of body2) {
|
||||
if (b === GLOBSTAR) {
|
||||
nonGsPartsSums.push(nonGsParts);
|
||||
currentBody = [[], 0];
|
||||
bodySegments.push(currentBody);
|
||||
} else {
|
||||
currentBody[0].push(b);
|
||||
nonGsParts++;
|
||||
}
|
||||
}
|
||||
let i = bodySegments.length - 1;
|
||||
const fileLength = file.length - fileTailMatch;
|
||||
for (const b of bodySegments) {
|
||||
b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
|
||||
}
|
||||
return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
|
||||
}
|
||||
// return false for "nope, not matching"
|
||||
// return null for "not matching, cannot keep trying"
|
||||
#matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
|
||||
const bs = bodySegments[bodyIndex];
|
||||
if (!bs) {
|
||||
for (let i = fileIndex; i < file.length; i++) {
|
||||
sawTail = true;
|
||||
const f = file[i];
|
||||
if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return sawTail;
|
||||
}
|
||||
const [body2, after] = bs;
|
||||
while (fileIndex <= after) {
|
||||
const m = this.#matchOne(file.slice(0, fileIndex + body2.length), body2, partial, fileIndex, 0);
|
||||
if (m && globStarDepth < this.maxGlobstarRecursion) {
|
||||
const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body2.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
|
||||
if (sub !== false) {
|
||||
return sub;
|
||||
}
|
||||
}
|
||||
const f = file[fileIndex];
|
||||
if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
|
||||
return false;
|
||||
}
|
||||
fileIndex++;
|
||||
}
|
||||
return partial || null;
|
||||
}
|
||||
#matchOne(file, pattern, partial, fileIndex, patternIndex) {
|
||||
let fi;
|
||||
let pi;
|
||||
let pl;
|
||||
let fl;
|
||||
for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
|
||||
this.debug("matchOne loop");
|
||||
let p = pattern[pi];
|
||||
let f = file[fi];
|
||||
this.debug(pattern, p, f);
|
||||
if (p === false || p === GLOBSTAR) {
|
||||
return false;
|
||||
}
|
||||
let hit;
|
||||
if (typeof p === "string") {
|
||||
hit = f === p;
|
||||
this.debug("string match", p, f, hit);
|
||||
} else {
|
||||
hit = p.test(f);
|
||||
this.debug("pattern match", p, f, hit);
|
||||
}
|
||||
if (!hit)
|
||||
return false;
|
||||
}
|
||||
if (fi === fl && pi === pl) {
|
||||
return true;
|
||||
} else if (fi === fl) {
|
||||
return partial;
|
||||
} else if (pi === pl) {
|
||||
return fi === fl - 1 && file[fi] === "";
|
||||
} else {
|
||||
throw new Error("wtf?");
|
||||
}
|
||||
}
|
||||
braceExpand() {
|
||||
return braceExpand(this.pattern, this.options);
|
||||
}
|
||||
parse(pattern) {
|
||||
assertValidPattern(pattern);
|
||||
const options = this.options;
|
||||
if (pattern === "**")
|
||||
return GLOBSTAR;
|
||||
if (pattern === "")
|
||||
return "";
|
||||
let m;
|
||||
let fastTest = null;
|
||||
if (m = pattern.match(starRE)) {
|
||||
fastTest = options.dot ? starTestDot : starTest;
|
||||
} else if (m = pattern.match(starDotExtRE)) {
|
||||
fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
|
||||
} else if (m = pattern.match(qmarksRE)) {
|
||||
fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
|
||||
} else if (m = pattern.match(starDotStarRE)) {
|
||||
fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
|
||||
} else if (m = pattern.match(dotStarRE)) {
|
||||
fastTest = dotStarTest;
|
||||
}
|
||||
const re = AST.fromGlob(pattern, this.options).toMMPattern();
|
||||
if (fastTest && typeof re === "object") {
|
||||
Reflect.defineProperty(re, "test", { value: fastTest });
|
||||
}
|
||||
return re;
|
||||
}
|
||||
makeRe() {
|
||||
if (this.regexp || this.regexp === false)
|
||||
return this.regexp;
|
||||
const set = this.set;
|
||||
if (!set.length) {
|
||||
this.regexp = false;
|
||||
return this.regexp;
|
||||
}
|
||||
const options = this.options;
|
||||
const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
|
||||
const flags = new Set(options.nocase ? ["i"] : []);
|
||||
let re = set.map((pattern) => {
|
||||
const pp = pattern.map((p) => {
|
||||
if (p instanceof RegExp) {
|
||||
for (const f of p.flags.split(""))
|
||||
flags.add(f);
|
||||
}
|
||||
return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
|
||||
});
|
||||
pp.forEach((p, i) => {
|
||||
const next = pp[i + 1];
|
||||
const prev = pp[i - 1];
|
||||
if (p !== GLOBSTAR || prev === GLOBSTAR) {
|
||||
return;
|
||||
}
|
||||
if (prev === void 0) {
|
||||
if (next !== void 0 && next !== GLOBSTAR) {
|
||||
pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
|
||||
} else {
|
||||
pp[i] = twoStar;
|
||||
}
|
||||
} else if (next === void 0) {
|
||||
pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
|
||||
} else if (next !== GLOBSTAR) {
|
||||
pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
|
||||
pp[i + 1] = GLOBSTAR;
|
||||
}
|
||||
});
|
||||
const filtered = pp.filter((p) => p !== GLOBSTAR);
|
||||
if (this.partial && filtered.length >= 1) {
|
||||
const prefixes = [];
|
||||
for (let i = 1; i <= filtered.length; i++) {
|
||||
prefixes.push(filtered.slice(0, i).join("/"));
|
||||
}
|
||||
return "(?:" + prefixes.join("|") + ")";
|
||||
}
|
||||
return filtered.join("/");
|
||||
}).join("|");
|
||||
const [open2, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
|
||||
re = "^" + open2 + re + close + "$";
|
||||
if (this.partial) {
|
||||
re = "^(?:\\/|" + open2 + re.slice(1, -1) + close + ")$";
|
||||
}
|
||||
if (this.negate)
|
||||
re = "^(?!" + re + ").+$";
|
||||
try {
|
||||
this.regexp = new RegExp(re, [...flags].join(""));
|
||||
} catch {
|
||||
this.regexp = false;
|
||||
}
|
||||
return this.regexp;
|
||||
}
|
||||
slashSplit(p) {
|
||||
if (this.preserveMultipleSlashes) {
|
||||
return p.split("/");
|
||||
} else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
|
||||
return ["", ...p.split(/\/+/)];
|
||||
} else {
|
||||
return p.split(/\/+/);
|
||||
}
|
||||
}
|
||||
match(f, partial = this.partial) {
|
||||
this.debug("match", f, this.pattern);
|
||||
if (this.comment) {
|
||||
return false;
|
||||
}
|
||||
if (this.empty) {
|
||||
return f === "";
|
||||
}
|
||||
if (f === "/" && partial) {
|
||||
return true;
|
||||
}
|
||||
const options = this.options;
|
||||
if (this.isWindows) {
|
||||
f = f.split("\\").join("/");
|
||||
}
|
||||
const ff = this.slashSplit(f);
|
||||
this.debug(this.pattern, "split", ff);
|
||||
const set = this.set;
|
||||
this.debug(this.pattern, "set", set);
|
||||
let filename = ff[ff.length - 1];
|
||||
if (!filename) {
|
||||
for (let i = ff.length - 2; !filename && i >= 0; i--) {
|
||||
filename = ff[i];
|
||||
}
|
||||
}
|
||||
for (const pattern of set) {
|
||||
let file = ff;
|
||||
if (options.matchBase && pattern.length === 1) {
|
||||
file = [filename];
|
||||
}
|
||||
const hit = this.matchOne(file, pattern, partial);
|
||||
if (hit) {
|
||||
if (options.flipNegate) {
|
||||
return true;
|
||||
}
|
||||
return !this.negate;
|
||||
}
|
||||
}
|
||||
if (options.flipNegate) {
|
||||
return false;
|
||||
}
|
||||
return this.negate;
|
||||
}
|
||||
static defaults(def) {
|
||||
return minimatch2.defaults(def).Minimatch;
|
||||
}
|
||||
};
|
||||
minimatch2.AST = AST;
|
||||
minimatch2.Minimatch = Minimatch2;
|
||||
minimatch2.escape = escape2;
|
||||
minimatch2.unescape = unescape;
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-path.js
|
||||
var IS_WINDOWS11 = process.platform === "win32";
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-pattern.js
|
||||
var IS_WINDOWS12 = process.platform === "win32";
|
||||
|
||||
// node_modules/@actions/glob/lib/internal-globber.js
|
||||
var IS_WINDOWS13 = process.platform === "win32";
|
||||
|
||||
// src/utils/logging.ts
|
||||
var quiet;
|
||||
function isQuiet() {
|
||||
@@ -61908,18 +63787,18 @@ var TomlDate = class _TomlDate extends Date {
|
||||
let hasTime = true;
|
||||
let offset = "Z";
|
||||
if (typeof date === "string") {
|
||||
let match2 = date.match(DATE_TIME_RE);
|
||||
if (match2) {
|
||||
if (!match2[1]) {
|
||||
let match4 = date.match(DATE_TIME_RE);
|
||||
if (match4) {
|
||||
if (!match4[1]) {
|
||||
hasDate = false;
|
||||
date = `0000-01-01T${date}`;
|
||||
}
|
||||
hasTime = !!match2[2];
|
||||
hasTime = !!match4[2];
|
||||
hasTime && date[10] === " " && (date = date.replace(" ", "T"));
|
||||
if (match2[2] && +match2[2] > 23) {
|
||||
if (match4[2] && +match4[2] > 23) {
|
||||
date = "";
|
||||
} else {
|
||||
offset = match2[3] || null;
|
||||
offset = match4[3] || null;
|
||||
date = date.toUpperCase();
|
||||
if (!offset && hasTime)
|
||||
date += "Z";
|
||||
@@ -62159,24 +64038,24 @@ function parseValue2(value, toml, ptr, integersAsBigInt) {
|
||||
});
|
||||
}
|
||||
value = value.replace(/_/g, "");
|
||||
let numeric = +value;
|
||||
if (isNaN(numeric)) {
|
||||
let numeric2 = +value;
|
||||
if (isNaN(numeric2)) {
|
||||
throw new TomlError("invalid number", {
|
||||
toml,
|
||||
ptr
|
||||
});
|
||||
}
|
||||
if (isInt) {
|
||||
if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
|
||||
if ((isInt = !Number.isSafeInteger(numeric2)) && !integersAsBigInt) {
|
||||
throw new TomlError("integer value cannot be represented losslessly", {
|
||||
toml,
|
||||
ptr
|
||||
});
|
||||
}
|
||||
if (isInt || integersAsBigInt === true)
|
||||
numeric = BigInt(value);
|
||||
numeric2 = BigInt(value);
|
||||
}
|
||||
return numeric;
|
||||
return numeric2;
|
||||
}
|
||||
const date = new TomlDate(value);
|
||||
if (!date.isValid()) {
|
||||
@@ -62222,7 +64101,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
function skipUntil(str, ptr, sep7, end, banNewLines = false) {
|
||||
function skipUntil(str, ptr, sep8, end, banNewLines = false) {
|
||||
if (!end) {
|
||||
ptr = indexOfNewline(str, ptr);
|
||||
return ptr < 0 ? str.length : ptr;
|
||||
@@ -62233,7 +64112,7 @@ function skipUntil(str, ptr, sep7, end, banNewLines = false) {
|
||||
i = indexOfNewline(str, i);
|
||||
if (i < 0)
|
||||
break;
|
||||
} else if (c === sep7) {
|
||||
} else if (c === sep8) {
|
||||
return i + 1;
|
||||
} else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
|
||||
return i;
|
||||
|
||||
Reference in New Issue
Block a user