github-action-readme-generator 1.12.8 → 2.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +17 -0
- package/README.md +14 -10
- package/action.yml +3 -1
- package/dist/bin/index.js +759 -529
- package/dist/mjs/index.d.ts +2 -3
- package/dist/mjs/index.js +118 -22
- package/package.json +6 -5
package/dist/bin/index.js
CHANGED
|
@@ -18,7 +18,7 @@ import { fileURLToPath } from "node:url";
|
|
|
18
18
|
import * as child from "child_process";
|
|
19
19
|
import { setTimeout as setTimeout$1 } from "timers";
|
|
20
20
|
import process$1 from "node:process";
|
|
21
|
-
import os$1
|
|
21
|
+
import os$1 from "node:os";
|
|
22
22
|
import tty from "node:tty";
|
|
23
23
|
import { execFileSync, execSync } from "node:child_process";
|
|
24
24
|
//#region \0rolldown/runtime.js
|
|
@@ -956,20 +956,22 @@ var require_tree = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
956
956
|
while (true) {
|
|
957
957
|
const code = key.charCodeAt(index);
|
|
958
958
|
if (code > 127) throw new TypeError("key must be ascii string");
|
|
959
|
-
if (node.code === code)
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
968
|
-
else {
|
|
969
|
-
node.left
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
959
|
+
if (node.code === code) {
|
|
960
|
+
if (length === ++index) {
|
|
961
|
+
node.value = value;
|
|
962
|
+
break;
|
|
963
|
+
} else if (node.middle !== null) node = node.middle;
|
|
964
|
+
else {
|
|
965
|
+
node.middle = new TstNode(key, value, index);
|
|
966
|
+
break;
|
|
967
|
+
}
|
|
968
|
+
} else if (node.code < code) {
|
|
969
|
+
if (node.left !== null) node = node.left;
|
|
970
|
+
else {
|
|
971
|
+
node.left = new TstNode(key, value, index);
|
|
972
|
+
break;
|
|
973
|
+
}
|
|
974
|
+
} else if (node.right !== null) node = node.right;
|
|
973
975
|
else {
|
|
974
976
|
node.right = new TstNode(key, value, index);
|
|
975
977
|
break;
|
|
@@ -1644,15 +1646,16 @@ var require_request$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
1644
1646
|
if (Array.isArray(headers)) {
|
|
1645
1647
|
if (headers.length % 2 !== 0) throw new InvalidArgumentError("headers array must be even");
|
|
1646
1648
|
for (let i = 0; i < headers.length; i += 2) processHeader(this, headers[i], headers[i + 1]);
|
|
1647
|
-
} else if (headers && typeof headers === "object")
|
|
1648
|
-
if (
|
|
1649
|
-
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
1653
|
-
|
|
1654
|
-
|
|
1655
|
-
|
|
1649
|
+
} else if (headers && typeof headers === "object") {
|
|
1650
|
+
if (headers[Symbol.iterator]) for (const header of headers) {
|
|
1651
|
+
if (!Array.isArray(header) || header.length !== 2) throw new InvalidArgumentError("headers must be in key-value pair format");
|
|
1652
|
+
processHeader(this, header[0], header[1]);
|
|
1653
|
+
}
|
|
1654
|
+
else {
|
|
1655
|
+
const keys = Object.keys(headers);
|
|
1656
|
+
for (let i = 0; i < keys.length; ++i) processHeader(this, keys[i], headers[keys[i]]);
|
|
1657
|
+
}
|
|
1658
|
+
} else if (headers != null) throw new InvalidArgumentError("headers must be an object or an array");
|
|
1656
1659
|
validateHandler(handler, method, upgrade);
|
|
1657
1660
|
this.servername = servername || getServerName(this.host);
|
|
1658
1661
|
this[kHandler] = handler;
|
|
@@ -4006,8 +4009,10 @@ var require_util$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
4006
4009
|
const algorithm = item.algo;
|
|
4007
4010
|
const expectedValue = item.hash;
|
|
4008
4011
|
let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
|
|
4009
|
-
if (actualValue[actualValue.length - 1] === "=")
|
|
4010
|
-
|
|
4012
|
+
if (actualValue[actualValue.length - 1] === "=") {
|
|
4013
|
+
if (actualValue[actualValue.length - 2] === "=") actualValue = actualValue.slice(0, -2);
|
|
4014
|
+
else actualValue = actualValue.slice(0, -1);
|
|
4015
|
+
}
|
|
4011
4016
|
if (compareBase64Mixed(actualValue, expectedValue)) return true;
|
|
4012
4017
|
}
|
|
4013
4018
|
return false;
|
|
@@ -4450,12 +4455,14 @@ var require_util$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
4450
4455
|
let temporaryValue = "";
|
|
4451
4456
|
while (position.position < input.length) {
|
|
4452
4457
|
temporaryValue += collectASequenceOfCodePoints((char) => char !== "\"" && char !== ",", input, position);
|
|
4453
|
-
if (position.position < input.length)
|
|
4454
|
-
|
|
4455
|
-
|
|
4456
|
-
|
|
4457
|
-
|
|
4458
|
-
|
|
4458
|
+
if (position.position < input.length) {
|
|
4459
|
+
if (input.charCodeAt(position.position) === 34) {
|
|
4460
|
+
temporaryValue += collectAnHTTPQuotedString(input, position);
|
|
4461
|
+
if (position.position < input.length) continue;
|
|
4462
|
+
} else {
|
|
4463
|
+
assert$23(input.charCodeAt(position.position) === 44);
|
|
4464
|
+
position.position++;
|
|
4465
|
+
}
|
|
4459
4466
|
}
|
|
4460
4467
|
temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32);
|
|
4461
4468
|
values.push(temporaryValue);
|
|
@@ -4705,9 +4712,10 @@ var require_formdata = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
4705
4712
|
}
|
|
4706
4713
|
[nodeUtil$2.inspect.custom](depth, options) {
|
|
4707
4714
|
const state = this[kState].reduce((a, b) => {
|
|
4708
|
-
if (a[b.name])
|
|
4709
|
-
|
|
4710
|
-
|
|
4715
|
+
if (a[b.name]) {
|
|
4716
|
+
if (Array.isArray(a[b.name])) a[b.name].push(b.value);
|
|
4717
|
+
else a[b.name] = [a[b.name], b.value];
|
|
4718
|
+
} else a[b.name] = b.value;
|
|
4711
4719
|
return a;
|
|
4712
4720
|
}, { __proto__: null });
|
|
4713
4721
|
options.depth ??= depth;
|
|
@@ -5322,10 +5330,12 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
5322
5330
|
timers.clearTimeout(this.timeout);
|
|
5323
5331
|
this.timeout = null;
|
|
5324
5332
|
}
|
|
5325
|
-
if (delay)
|
|
5326
|
-
|
|
5327
|
-
|
|
5328
|
-
|
|
5333
|
+
if (delay) {
|
|
5334
|
+
if (type & USE_FAST_TIMER) this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this));
|
|
5335
|
+
else {
|
|
5336
|
+
this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this));
|
|
5337
|
+
this.timeout.unref();
|
|
5338
|
+
}
|
|
5329
5339
|
}
|
|
5330
5340
|
this.timeoutValue = delay;
|
|
5331
5341
|
} else if (this.timeout) {
|
|
@@ -5873,9 +5883,10 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
5873
5883
|
/* istanbul ignore else: assertion */
|
|
5874
5884
|
if (!body || bodyLength === 0) writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload);
|
|
5875
5885
|
else if (util.isBuffer(body)) writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload);
|
|
5876
|
-
else if (util.isBlobLike(body))
|
|
5877
|
-
|
|
5878
|
-
|
|
5886
|
+
else if (util.isBlobLike(body)) {
|
|
5887
|
+
if (typeof body.stream === "function") writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload);
|
|
5888
|
+
else writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload);
|
|
5889
|
+
} else if (util.isStream(body)) writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload);
|
|
5879
5890
|
else if (util.isIterable(body)) writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload);
|
|
5880
5891
|
else assert$20(false);
|
|
5881
5892
|
return true;
|
|
@@ -5937,12 +5948,13 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
5937
5948
|
}
|
|
5938
5949
|
function writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload) {
|
|
5939
5950
|
try {
|
|
5940
|
-
if (!body)
|
|
5941
|
-
|
|
5942
|
-
|
|
5943
|
-
|
|
5944
|
-
|
|
5945
|
-
|
|
5951
|
+
if (!body) {
|
|
5952
|
+
if (contentLength === 0) socket.write(`${header}content-length: 0\r\n\r\n`, "latin1");
|
|
5953
|
+
else {
|
|
5954
|
+
assert$20(contentLength === null, "no body must not have content length");
|
|
5955
|
+
socket.write(`${header}\r\n`, "latin1");
|
|
5956
|
+
}
|
|
5957
|
+
} else if (util.isBuffer(body)) {
|
|
5946
5958
|
assert$20(contentLength === body.byteLength, "buffer body must have content length");
|
|
5947
5959
|
socket.cork();
|
|
5948
5960
|
socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1");
|
|
@@ -6058,11 +6070,14 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
6058
6070
|
socket[kWriting] = false;
|
|
6059
6071
|
if (socket[kError]) throw socket[kError];
|
|
6060
6072
|
if (socket.destroyed) return;
|
|
6061
|
-
if (bytesWritten === 0)
|
|
6062
|
-
|
|
6063
|
-
|
|
6064
|
-
if (contentLength
|
|
6065
|
-
|
|
6073
|
+
if (bytesWritten === 0) {
|
|
6074
|
+
if (expectsPayload) socket.write(`${header}content-length: 0\r\n\r\n`, "latin1");
|
|
6075
|
+
else socket.write(`${header}\r\n`, "latin1");
|
|
6076
|
+
} else if (contentLength === null) socket.write("\r\n0\r\n\r\n", "latin1");
|
|
6077
|
+
if (contentLength !== null && bytesWritten !== contentLength) {
|
|
6078
|
+
if (client[kStrictContentLength]) throw new RequestContentLengthMismatchError();
|
|
6079
|
+
else process.emitWarning(new RequestContentLengthMismatchError());
|
|
6080
|
+
}
|
|
6066
6081
|
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
|
|
6067
6082
|
// istanbul ignore else: only for jest
|
|
6068
6083
|
if (socket[kParser].timeout.refresh) socket[kParser].timeout.refresh();
|
|
@@ -6183,12 +6198,14 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
6183
6198
|
}
|
|
6184
6199
|
function resumeH2(client) {
|
|
6185
6200
|
const socket = client[kSocket];
|
|
6186
|
-
if (socket?.destroyed === false)
|
|
6187
|
-
|
|
6188
|
-
|
|
6189
|
-
|
|
6190
|
-
|
|
6191
|
-
|
|
6201
|
+
if (socket?.destroyed === false) {
|
|
6202
|
+
if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
|
|
6203
|
+
socket.unref();
|
|
6204
|
+
client[kHTTP2Session].unref();
|
|
6205
|
+
} else {
|
|
6206
|
+
socket.ref();
|
|
6207
|
+
client[kHTTP2Session].ref();
|
|
6208
|
+
}
|
|
6192
6209
|
}
|
|
6193
6210
|
}
|
|
6194
6211
|
function onHttp2SessionError(err) {
|
|
@@ -6372,9 +6389,10 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
6372
6389
|
/* istanbul ignore else: assertion */
|
|
6373
6390
|
if (!body || contentLength === 0) writeBuffer(abort, stream, null, client, request, client[kSocket], contentLength, expectsPayload);
|
|
6374
6391
|
else if (util.isBuffer(body)) writeBuffer(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
|
|
6375
|
-
else if (util.isBlobLike(body))
|
|
6376
|
-
|
|
6377
|
-
|
|
6392
|
+
else if (util.isBlobLike(body)) {
|
|
6393
|
+
if (typeof body.stream === "function") writeIterable(abort, stream, body.stream(), client, request, client[kSocket], contentLength, expectsPayload);
|
|
6394
|
+
else writeBlob(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
|
|
6395
|
+
} else if (util.isStream(body)) writeStream(abort, client[kSocket], expectsPayload, stream, body, client, request, contentLength);
|
|
6378
6396
|
else if (util.isIterable(body)) writeIterable(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
|
|
6379
6397
|
else assert$19(false);
|
|
6380
6398
|
}
|
|
@@ -7837,13 +7855,15 @@ var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) =>
|
|
|
7837
7855
|
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
|
|
7838
7856
|
const headers = parseHeaders(rawHeaders);
|
|
7839
7857
|
this.retryCount += 1;
|
|
7840
|
-
if (statusCode >= 300)
|
|
7841
|
-
|
|
7842
|
-
|
|
7843
|
-
|
|
7844
|
-
|
|
7845
|
-
|
|
7846
|
-
|
|
7858
|
+
if (statusCode >= 300) {
|
|
7859
|
+
if (this.retryOpts.statusCodes.includes(statusCode) === false) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage);
|
|
7860
|
+
else {
|
|
7861
|
+
this.abort(new RequestRetryError("Request failed", statusCode, {
|
|
7862
|
+
headers,
|
|
7863
|
+
data: { count: this.retryCount }
|
|
7864
|
+
}));
|
|
7865
|
+
return false;
|
|
7866
|
+
}
|
|
7847
7867
|
}
|
|
7848
7868
|
if (this.resume != null) {
|
|
7849
7869
|
this.resume = null;
|
|
@@ -8310,17 +8330,19 @@ var require_api_request = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
8310
8330
|
if (util.isStream(body)) body.on("error", (err) => {
|
|
8311
8331
|
this.onError(err);
|
|
8312
8332
|
});
|
|
8313
|
-
if (this.signal)
|
|
8314
|
-
|
|
8315
|
-
this.
|
|
8316
|
-
|
|
8317
|
-
|
|
8318
|
-
|
|
8319
|
-
|
|
8320
|
-
|
|
8321
|
-
|
|
8322
|
-
|
|
8323
|
-
|
|
8333
|
+
if (this.signal) {
|
|
8334
|
+
if (this.signal.aborted) this.reason = this.signal.reason ?? new RequestAbortedError();
|
|
8335
|
+
else this.removeAbortListener = util.addAbortListener(this.signal, () => {
|
|
8336
|
+
this.reason = this.signal.reason ?? new RequestAbortedError();
|
|
8337
|
+
if (this.res) util.destroy(this.res.on("error", util.nop), this.reason);
|
|
8338
|
+
else if (this.abort) this.abort(this.reason);
|
|
8339
|
+
if (this.removeAbortListener) {
|
|
8340
|
+
this.res?.off("close", this.removeAbortListener);
|
|
8341
|
+
this.removeAbortListener();
|
|
8342
|
+
this.removeAbortListener = null;
|
|
8343
|
+
}
|
|
8344
|
+
});
|
|
8345
|
+
}
|
|
8324
8346
|
}
|
|
8325
8347
|
onConnect(abort, context) {
|
|
8326
8348
|
if (this.reason) {
|
|
@@ -8354,22 +8376,24 @@ var require_api_request = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
8354
8376
|
if (this.removeAbortListener) res.on("close", this.removeAbortListener);
|
|
8355
8377
|
this.callback = null;
|
|
8356
8378
|
this.res = res;
|
|
8357
|
-
if (callback !== null)
|
|
8358
|
-
|
|
8359
|
-
|
|
8360
|
-
|
|
8361
|
-
|
|
8362
|
-
|
|
8363
|
-
|
|
8364
|
-
|
|
8365
|
-
|
|
8366
|
-
|
|
8367
|
-
|
|
8368
|
-
|
|
8369
|
-
|
|
8370
|
-
|
|
8371
|
-
|
|
8372
|
-
|
|
8379
|
+
if (callback !== null) {
|
|
8380
|
+
if (this.throwOnError && statusCode >= 400) this.runInAsyncScope(getResolveErrorBodyCallback, null, {
|
|
8381
|
+
callback,
|
|
8382
|
+
body: res,
|
|
8383
|
+
contentType,
|
|
8384
|
+
statusCode,
|
|
8385
|
+
statusMessage,
|
|
8386
|
+
headers
|
|
8387
|
+
});
|
|
8388
|
+
else this.runInAsyncScope(callback, null, null, {
|
|
8389
|
+
statusCode,
|
|
8390
|
+
headers,
|
|
8391
|
+
trailers: this.trailers,
|
|
8392
|
+
opaque,
|
|
8393
|
+
body: res,
|
|
8394
|
+
context
|
|
8395
|
+
});
|
|
8396
|
+
}
|
|
8373
8397
|
}
|
|
8374
8398
|
onData(chunk) {
|
|
8375
8399
|
return this.res.push(chunk);
|
|
@@ -9268,10 +9292,12 @@ var require_mock_interceptor = /* @__PURE__ */ __commonJSMin(((exports, module)
|
|
|
9268
9292
|
if (typeof opts !== "object") throw new InvalidArgumentError("opts must be an object");
|
|
9269
9293
|
if (typeof opts.path === "undefined") throw new InvalidArgumentError("opts.path must be defined");
|
|
9270
9294
|
if (typeof opts.method === "undefined") opts.method = "GET";
|
|
9271
|
-
if (typeof opts.path === "string")
|
|
9272
|
-
|
|
9273
|
-
|
|
9274
|
-
|
|
9295
|
+
if (typeof opts.path === "string") {
|
|
9296
|
+
if (opts.query) opts.path = buildURL(opts.path, opts.query);
|
|
9297
|
+
else {
|
|
9298
|
+
const parsedURL = new URL(opts.path, "data://");
|
|
9299
|
+
opts.path = parsedURL.pathname + parsedURL.search;
|
|
9300
|
+
}
|
|
9275
9301
|
}
|
|
9276
9302
|
if (typeof opts.method === "string") opts.method = opts.method.toUpperCase();
|
|
9277
9303
|
this[kDispatchKey] = buildKey(opts);
|
|
@@ -9562,9 +9588,10 @@ var require_mock_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
9562
9588
|
this[kIsMockActive] = true;
|
|
9563
9589
|
}
|
|
9564
9590
|
enableNetConnect(matcher) {
|
|
9565
|
-
if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp)
|
|
9566
|
-
|
|
9567
|
-
|
|
9591
|
+
if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
|
|
9592
|
+
if (Array.isArray(this[kNetConnect])) this[kNetConnect].push(matcher);
|
|
9593
|
+
else this[kNetConnect] = [matcher];
|
|
9594
|
+
} else if (typeof matcher === "undefined") this[kNetConnect] = true;
|
|
9568
9595
|
else throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
|
|
9569
9596
|
}
|
|
9570
9597
|
disableNetConnect() {
|
|
@@ -9867,12 +9894,14 @@ var require_dns = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
9867
9894
|
const { records, offset } = hostnameRecords;
|
|
9868
9895
|
let family;
|
|
9869
9896
|
if (this.dualStack) {
|
|
9870
|
-
if (affinity == null)
|
|
9871
|
-
|
|
9872
|
-
|
|
9873
|
-
|
|
9874
|
-
|
|
9875
|
-
|
|
9897
|
+
if (affinity == null) {
|
|
9898
|
+
if (offset == null || offset === maxInt) {
|
|
9899
|
+
hostnameRecords.offset = 0;
|
|
9900
|
+
affinity = 4;
|
|
9901
|
+
} else {
|
|
9902
|
+
hostnameRecords.offset++;
|
|
9903
|
+
affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4;
|
|
9904
|
+
}
|
|
9876
9905
|
}
|
|
9877
9906
|
if (records[affinity] != null && records[affinity].ips.length > 0) family = records[affinity];
|
|
9878
9907
|
else family = records[affinity === 4 ? 6 : 4];
|
|
@@ -11368,8 +11397,10 @@ var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
11368
11397
|
assert$5(!request.body || request.body.stream);
|
|
11369
11398
|
if (request.window === "client") request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
|
|
11370
11399
|
if (request.origin === "client") request.origin = request.client.origin;
|
|
11371
|
-
if (request.policyContainer === "client")
|
|
11372
|
-
|
|
11400
|
+
if (request.policyContainer === "client") {
|
|
11401
|
+
if (request.client != null) request.policyContainer = clonePolicyContainer(request.client.policyContainer);
|
|
11402
|
+
else request.policyContainer = makePolicyContainer();
|
|
11403
|
+
}
|
|
11373
11404
|
if (!request.headersList.contains("accept", true)) request.headersList.append("accept", "*/*", true);
|
|
11374
11405
|
if (!request.headersList.contains("accept-language", true)) request.headersList.append("accept-language", "*", true);
|
|
11375
11406
|
if (request.priority === null) {}
|
|
@@ -11638,8 +11669,10 @@ var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
11638
11669
|
if (!httpRequest.headersList.contains("cache-control", true)) httpRequest.headersList.append("cache-control", "no-cache", true);
|
|
11639
11670
|
}
|
|
11640
11671
|
if (httpRequest.headersList.contains("range", true)) httpRequest.headersList.append("accept-encoding", "identity", true);
|
|
11641
|
-
if (!httpRequest.headersList.contains("accept-encoding", true))
|
|
11642
|
-
|
|
11672
|
+
if (!httpRequest.headersList.contains("accept-encoding", true)) {
|
|
11673
|
+
if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", true);
|
|
11674
|
+
else httpRequest.headersList.append("accept-encoding", "gzip, deflate", true);
|
|
11675
|
+
}
|
|
11643
11676
|
httpRequest.headersList.delete("host", true);
|
|
11644
11677
|
if (includeCredentials) {}
|
|
11645
11678
|
httpRequest.cache = "no-store";
|
|
@@ -14093,8 +14126,10 @@ var require_util$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
14093
14126
|
failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
|
|
14094
14127
|
return;
|
|
14095
14128
|
}
|
|
14096
|
-
else if (type === opcodes.BINARY)
|
|
14097
|
-
|
|
14129
|
+
else if (type === opcodes.BINARY) {
|
|
14130
|
+
if (ws[kBinaryType] === "blob") dataForEvent = new Blob([data]);
|
|
14131
|
+
else dataForEvent = toArrayBuffer(data);
|
|
14132
|
+
}
|
|
14098
14133
|
fireEvent("message", ws, createFastMessageEvent, {
|
|
14099
14134
|
origin: ws[kWebSocketURL].origin,
|
|
14100
14135
|
data: dataForEvent
|
|
@@ -15655,13 +15690,15 @@ var require_eventsource = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
15655
15690
|
};
|
|
15656
15691
|
fetchParams.processResponseEndOfBody = processEventSourceEndOfBody;
|
|
15657
15692
|
fetchParams.processResponse = (response) => {
|
|
15658
|
-
if (isNetworkError(response))
|
|
15659
|
-
|
|
15660
|
-
|
|
15661
|
-
|
|
15662
|
-
|
|
15663
|
-
|
|
15664
|
-
|
|
15693
|
+
if (isNetworkError(response)) {
|
|
15694
|
+
if (response.aborted) {
|
|
15695
|
+
this.close();
|
|
15696
|
+
this.dispatchEvent(new Event("error"));
|
|
15697
|
+
return;
|
|
15698
|
+
} else {
|
|
15699
|
+
this.#reconnect();
|
|
15700
|
+
return;
|
|
15701
|
+
}
|
|
15665
15702
|
}
|
|
15666
15703
|
const contentType = response.headersList.get("content-type", true);
|
|
15667
15704
|
const mimeType = contentType !== null ? parseMIMEType(contentType) : "failure";
|
|
@@ -16493,8 +16530,10 @@ function which(tool, check) {
|
|
|
16493
16530
|
if (!tool) throw new Error("parameter 'tool' is required");
|
|
16494
16531
|
if (check) {
|
|
16495
16532
|
const result = yield which(tool, false);
|
|
16496
|
-
if (!result)
|
|
16497
|
-
|
|
16533
|
+
if (!result) {
|
|
16534
|
+
if (IS_WINDOWS$1) throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
|
|
16535
|
+
else throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
|
|
16536
|
+
}
|
|
16498
16537
|
return result;
|
|
16499
16538
|
}
|
|
16500
16539
|
const matches = yield findInPath(tool);
|
|
@@ -16577,17 +16616,18 @@ var ToolRunner = class extends events.EventEmitter {
|
|
|
16577
16616
|
const toolPath = this._getSpawnFileName();
|
|
16578
16617
|
const args = this._getSpawnArgs(options);
|
|
16579
16618
|
let cmd = noPrefix ? "" : "[command]";
|
|
16580
|
-
if (IS_WINDOWS)
|
|
16581
|
-
|
|
16582
|
-
|
|
16583
|
-
|
|
16584
|
-
|
|
16585
|
-
|
|
16619
|
+
if (IS_WINDOWS) {
|
|
16620
|
+
if (this._isCmdFile()) {
|
|
16621
|
+
cmd += toolPath;
|
|
16622
|
+
for (const a of args) cmd += ` ${a}`;
|
|
16623
|
+
} else if (options.windowsVerbatimArguments) {
|
|
16624
|
+
cmd += `"${toolPath}"`;
|
|
16625
|
+
for (const a of args) cmd += ` ${a}`;
|
|
16626
|
+
} else {
|
|
16627
|
+
cmd += this._windowsQuoteCmdArg(toolPath);
|
|
16628
|
+
for (const a of args) cmd += ` ${this._windowsQuoteCmdArg(a)}`;
|
|
16629
|
+
}
|
|
16586
16630
|
} else {
|
|
16587
|
-
cmd += this._windowsQuoteCmdArg(toolPath);
|
|
16588
|
-
for (const a of args) cmd += ` ${this._windowsQuoteCmdArg(a)}`;
|
|
16589
|
-
}
|
|
16590
|
-
else {
|
|
16591
16631
|
cmd += toolPath;
|
|
16592
16632
|
for (const a of args) cmd += ` ${a}`;
|
|
16593
16633
|
}
|
|
@@ -17015,10 +17055,12 @@ var Context$1 = class {
|
|
|
17015
17055
|
constructor() {
|
|
17016
17056
|
var _a, _b, _c;
|
|
17017
17057
|
this.payload = {};
|
|
17018
|
-
if (process.env.GITHUB_EVENT_PATH)
|
|
17019
|
-
|
|
17020
|
-
|
|
17021
|
-
|
|
17058
|
+
if (process.env.GITHUB_EVENT_PATH) {
|
|
17059
|
+
if (existsSync$1(process.env.GITHUB_EVENT_PATH)) this.payload = JSON.parse(readFileSync$1(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" }));
|
|
17060
|
+
else {
|
|
17061
|
+
const path = process.env.GITHUB_EVENT_PATH;
|
|
17062
|
+
process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${EOL}`);
|
|
17063
|
+
}
|
|
17022
17064
|
}
|
|
17023
17065
|
this.eventName = process.env.GITHUB_EVENT_NAME;
|
|
17024
17066
|
this.sha = process.env.GITHUB_SHA;
|
|
@@ -17576,14 +17618,18 @@ var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
17576
17618
|
let clientHeader;
|
|
17577
17619
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
17578
17620
|
const headerValue = lowercaseKeys(this.requestOptions.headers)[Headers.ContentType];
|
|
17579
|
-
if (headerValue)
|
|
17580
|
-
|
|
17581
|
-
|
|
17621
|
+
if (headerValue) {
|
|
17622
|
+
if (typeof headerValue === "number") clientHeader = String(headerValue);
|
|
17623
|
+
else if (Array.isArray(headerValue)) clientHeader = headerValue.join(", ");
|
|
17624
|
+
else clientHeader = headerValue;
|
|
17625
|
+
}
|
|
17582
17626
|
}
|
|
17583
17627
|
const additionalValue = additionalHeaders[Headers.ContentType];
|
|
17584
|
-
if (additionalValue !== void 0)
|
|
17585
|
-
|
|
17586
|
-
|
|
17628
|
+
if (additionalValue !== void 0) {
|
|
17629
|
+
if (typeof additionalValue === "number") return String(additionalValue);
|
|
17630
|
+
else if (Array.isArray(additionalValue)) return additionalValue.join(", ");
|
|
17631
|
+
else return additionalValue;
|
|
17632
|
+
}
|
|
17587
17633
|
if (clientHeader !== void 0) return clientHeader;
|
|
17588
17634
|
return _default;
|
|
17589
17635
|
}
|
|
@@ -17867,9 +17913,10 @@ function isPlainObject$1(value) {
|
|
|
17867
17913
|
function mergeDeep(defaults, options) {
|
|
17868
17914
|
const result = Object.assign({}, defaults);
|
|
17869
17915
|
Object.keys(options).forEach((key) => {
|
|
17870
|
-
if (isPlainObject$1(options[key]))
|
|
17871
|
-
|
|
17872
|
-
|
|
17916
|
+
if (isPlainObject$1(options[key])) {
|
|
17917
|
+
if (!(key in defaults)) Object.assign(result, { [key]: options[key] });
|
|
17918
|
+
else result[key] = mergeDeep(defaults[key], options[key]);
|
|
17919
|
+
} else Object.assign(result, { [key]: options[key] });
|
|
17873
17920
|
});
|
|
17874
17921
|
return result;
|
|
17875
17922
|
}
|
|
@@ -17942,31 +17989,33 @@ function isKeyOperator(operator) {
|
|
|
17942
17989
|
}
|
|
17943
17990
|
function getValues(context, operator, key, modifier) {
|
|
17944
17991
|
var value = context[key], result = [];
|
|
17945
|
-
if (isDefined(value) && value !== "")
|
|
17946
|
-
value
|
|
17947
|
-
|
|
17948
|
-
|
|
17949
|
-
|
|
17950
|
-
|
|
17951
|
-
|
|
17952
|
-
|
|
17953
|
-
|
|
17954
|
-
|
|
17955
|
-
|
|
17956
|
-
|
|
17957
|
-
|
|
17958
|
-
tmp
|
|
17959
|
-
|
|
17960
|
-
|
|
17961
|
-
|
|
17962
|
-
|
|
17963
|
-
|
|
17964
|
-
|
|
17965
|
-
|
|
17966
|
-
|
|
17967
|
-
|
|
17968
|
-
|
|
17969
|
-
|
|
17992
|
+
if (isDefined(value) && value !== "") {
|
|
17993
|
+
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
|
|
17994
|
+
value = value.toString();
|
|
17995
|
+
if (modifier && modifier !== "*") value = value.substring(0, parseInt(modifier, 10));
|
|
17996
|
+
result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
|
|
17997
|
+
} else if (modifier === "*") {
|
|
17998
|
+
if (Array.isArray(value)) value.filter(isDefined).forEach(function(value2) {
|
|
17999
|
+
result.push(encodeValue(operator, value2, isKeyOperator(operator) ? key : ""));
|
|
18000
|
+
});
|
|
18001
|
+
else Object.keys(value).forEach(function(k) {
|
|
18002
|
+
if (isDefined(value[k])) result.push(encodeValue(operator, value[k], k));
|
|
18003
|
+
});
|
|
18004
|
+
} else {
|
|
18005
|
+
const tmp = [];
|
|
18006
|
+
if (Array.isArray(value)) value.filter(isDefined).forEach(function(value2) {
|
|
18007
|
+
tmp.push(encodeValue(operator, value2));
|
|
18008
|
+
});
|
|
18009
|
+
else Object.keys(value).forEach(function(k) {
|
|
18010
|
+
if (isDefined(value[k])) {
|
|
18011
|
+
tmp.push(encodeUnreserved(k));
|
|
18012
|
+
tmp.push(encodeValue(operator, value[k].toString()));
|
|
18013
|
+
}
|
|
18014
|
+
});
|
|
18015
|
+
if (isKeyOperator(operator)) result.push(encodeUnreserved(key) + "=" + tmp.join(","));
|
|
18016
|
+
else if (tmp.length !== 0) result.push(tmp.join(","));
|
|
18017
|
+
}
|
|
18018
|
+
} else if (operator === ";") {
|
|
17970
18019
|
if (isDefined(value)) result.push(encodeUnreserved(key));
|
|
17971
18020
|
} else if (value === "" && (operator === "&" || operator === "?")) result.push(encodeUnreserved(key) + "=");
|
|
17972
18021
|
else if (value === "") result.push("");
|
|
@@ -18520,13 +18569,14 @@ var Octokit = class {
|
|
|
18520
18569
|
this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
|
|
18521
18570
|
this.log = createLogger(options.log);
|
|
18522
18571
|
this.hook = hook;
|
|
18523
|
-
if (!options.authStrategy)
|
|
18524
|
-
|
|
18525
|
-
|
|
18526
|
-
|
|
18527
|
-
|
|
18528
|
-
|
|
18529
|
-
|
|
18572
|
+
if (!options.authStrategy) {
|
|
18573
|
+
if (!options.auth) this.auth = async () => ({ type: "unauthenticated" });
|
|
18574
|
+
else {
|
|
18575
|
+
const auth = createTokenAuth(options.auth);
|
|
18576
|
+
hook.wrap("request", auth.hook);
|
|
18577
|
+
this.auth = auth;
|
|
18578
|
+
}
|
|
18579
|
+
} else {
|
|
18530
18580
|
const { authStrategy, ...otherOptions } = options;
|
|
18531
18581
|
const auth = authStrategy(Object.assign({
|
|
18532
18582
|
request: this.request,
|
|
@@ -25743,11 +25793,13 @@ var require_memory = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
25743
25793
|
Memory.prototype.set = function(key, value) {
|
|
25744
25794
|
if (this.readOnly) return false;
|
|
25745
25795
|
var target = this.store, path = common.path(key, this.logicalSeparator);
|
|
25746
|
-
if (path.length === 0)
|
|
25747
|
-
|
|
25748
|
-
|
|
25749
|
-
|
|
25750
|
-
|
|
25796
|
+
if (path.length === 0) {
|
|
25797
|
+
if (!value || typeof value !== "object") return false;
|
|
25798
|
+
else {
|
|
25799
|
+
this.reset();
|
|
25800
|
+
this.store = value;
|
|
25801
|
+
return true;
|
|
25802
|
+
}
|
|
25751
25803
|
}
|
|
25752
25804
|
this.mtimes[key] = Date.now();
|
|
25753
25805
|
while (path.length > 1) {
|
|
@@ -26580,9 +26632,11 @@ var require_build$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
26580
26632
|
continue;
|
|
26581
26633
|
} else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
|
|
26582
26634
|
m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
|
|
26583
|
-
if (m !== null && Array.isArray(m) && m.length >= 3)
|
|
26584
|
-
|
|
26585
|
-
|
|
26635
|
+
if (m !== null && Array.isArray(m) && m.length >= 3) {
|
|
26636
|
+
if (checkAllAliases(m[1], flags.arrays)) i = eatArray(i, m[1], args, m[2]);
|
|
26637
|
+
else if (checkAllAliases(m[1], flags.nargs) !== false) i = eatNargs(i, m[1], args, m[2]);
|
|
26638
|
+
else setArg(m[1], m[2]);
|
|
26639
|
+
}
|
|
26586
26640
|
} else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
|
|
26587
26641
|
m = arg.match(negatedBoolean);
|
|
26588
26642
|
if (m !== null && Array.isArray(m) && m.length >= 2) {
|
|
@@ -26649,17 +26703,19 @@ var require_build$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
26649
26703
|
} else setArg(letters[j], defaultValue(letters[j]));
|
|
26650
26704
|
}
|
|
26651
26705
|
key = arg.slice(-1)[0];
|
|
26652
|
-
if (!broken && key !== "-")
|
|
26653
|
-
|
|
26654
|
-
|
|
26655
|
-
|
|
26656
|
-
|
|
26657
|
-
|
|
26658
|
-
|
|
26659
|
-
|
|
26660
|
-
|
|
26661
|
-
|
|
26662
|
-
|
|
26706
|
+
if (!broken && key !== "-") {
|
|
26707
|
+
if (checkAllAliases(key, flags.arrays)) i = eatArray(i, key, args);
|
|
26708
|
+
else if (checkAllAliases(key, flags.nargs) !== false) i = eatNargs(i, key, args);
|
|
26709
|
+
else {
|
|
26710
|
+
next = args[i + 1];
|
|
26711
|
+
if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
|
|
26712
|
+
setArg(key, next);
|
|
26713
|
+
i++;
|
|
26714
|
+
} else if (/^(true|false)$/.test(next)) {
|
|
26715
|
+
setArg(key, next);
|
|
26716
|
+
i++;
|
|
26717
|
+
} else setArg(key, defaultValue(key));
|
|
26718
|
+
}
|
|
26663
26719
|
}
|
|
26664
26720
|
} else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
|
|
26665
26721
|
key = arg.slice(1);
|
|
@@ -26793,10 +26849,12 @@ var require_build$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
26793
26849
|
return maybeCoerceNumber(key, v);
|
|
26794
26850
|
}) : maybeCoerceNumber(key, val);
|
|
26795
26851
|
if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) value = increment();
|
|
26796
|
-
if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays))
|
|
26797
|
-
|
|
26798
|
-
|
|
26799
|
-
|
|
26852
|
+
if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
|
|
26853
|
+
if (Array.isArray(val)) value = val.map((val) => {
|
|
26854
|
+
return mixin.normalize(val);
|
|
26855
|
+
});
|
|
26856
|
+
else value = mixin.normalize(val);
|
|
26857
|
+
}
|
|
26800
26858
|
return value;
|
|
26801
26859
|
}
|
|
26802
26860
|
function maybeCoerceNumber(key, value) {
|
|
@@ -26928,10 +26986,11 @@ var require_build$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
26928
26986
|
if (!isUndefined(o[key]) && flags.nargs[key] === 1 || Array.isArray(o[key]) && o[key].length === flags.nargs[key]) o[key] = void 0;
|
|
26929
26987
|
}
|
|
26930
26988
|
if (value === increment()) o[key] = increment(o[key]);
|
|
26931
|
-
else if (Array.isArray(o[key]))
|
|
26932
|
-
|
|
26933
|
-
|
|
26934
|
-
|
|
26989
|
+
else if (Array.isArray(o[key])) {
|
|
26990
|
+
if (duplicate && isTypeArray && isValueArray) o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
|
|
26991
|
+
else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) o[key] = value;
|
|
26992
|
+
else o[key] = o[key].concat([value]);
|
|
26993
|
+
} else if (o[key] === void 0 && isTypeArray) o[key] = isValueArray ? value : [value];
|
|
26935
26994
|
else if (duplicate && !(o[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) o[key] = [o[key], value];
|
|
26936
26995
|
else o[key] = value;
|
|
26937
26996
|
}
|
|
@@ -29599,9 +29658,10 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
29599
29658
|
let aliases = [];
|
|
29600
29659
|
const middlewares = commandMiddlewareFactory(commandMiddleware);
|
|
29601
29660
|
handler = handler || (() => {});
|
|
29602
|
-
if (Array.isArray(cmd))
|
|
29603
|
-
|
|
29604
|
-
|
|
29661
|
+
if (Array.isArray(cmd)) {
|
|
29662
|
+
if (isCommandAndAliases(cmd)) [cmd, ...aliases] = cmd;
|
|
29663
|
+
else for (const command of cmd) self.addHandler(command);
|
|
29664
|
+
} else if (isCommandHandlerDefinition(cmd)) {
|
|
29605
29665
|
let command = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : moduleName(cmd);
|
|
29606
29666
|
if (cmd.aliases) command = [].concat(command).concat(cmd.aliases);
|
|
29607
29667
|
self.addHandler(command, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
|
|
@@ -30067,8 +30127,10 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
30067
30127
|
const hints = [];
|
|
30068
30128
|
if (command[2]) hints.push(`[${__("default")}]`);
|
|
30069
30129
|
if (command[3] && command[3].length) hints.push(`[${__("aliases:")} ${command[3].join(", ")}]`);
|
|
30070
|
-
if (command[4])
|
|
30071
|
-
|
|
30130
|
+
if (command[4]) {
|
|
30131
|
+
if (typeof command[4] === "string") hints.push(`[${__("deprecated: %s", command[4])}]`);
|
|
30132
|
+
else hints.push(`[${__("deprecated")}]`);
|
|
30133
|
+
}
|
|
30072
30134
|
if (hints.length) ui.div({
|
|
30073
30135
|
text: hints.join(" "),
|
|
30074
30136
|
padding: [
|
|
@@ -30430,10 +30492,12 @@ compdef _{{app_name}}_yargs_completions {{app_name}}
|
|
|
30430
30492
|
}
|
|
30431
30493
|
if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current) usage.getCommands().forEach((usageCommand) => {
|
|
30432
30494
|
const commandName = parseCommand(usageCommand[0]).cmd;
|
|
30433
|
-
if (args.indexOf(commandName) === -1)
|
|
30434
|
-
|
|
30435
|
-
|
|
30436
|
-
|
|
30495
|
+
if (args.indexOf(commandName) === -1) {
|
|
30496
|
+
if (!zshShell) completions.push(commandName);
|
|
30497
|
+
else {
|
|
30498
|
+
const desc = usageCommand[1] || "";
|
|
30499
|
+
completions.push(commandName.replace(/:/g, "\\:") + ":" + desc);
|
|
30500
|
+
}
|
|
30437
30501
|
}
|
|
30438
30502
|
});
|
|
30439
30503
|
if (current.match(/^-/) || current === "" && completions.length === 0) {
|
|
@@ -30482,10 +30546,10 @@ compdef _{{app_name}}_yargs_completions {{app_name}}
|
|
|
30482
30546
|
if (a.length === 0) return b.length;
|
|
30483
30547
|
if (b.length === 0) return a.length;
|
|
30484
30548
|
const matrix = [];
|
|
30485
|
-
let i;
|
|
30486
|
-
for (
|
|
30487
|
-
let j;
|
|
30488
|
-
for (
|
|
30549
|
+
let i = 0;
|
|
30550
|
+
for (; i <= b.length; i++) matrix[i] = [i];
|
|
30551
|
+
let j = 0;
|
|
30552
|
+
for (; j <= a.length; j++) matrix[0][j] = j;
|
|
30489
30553
|
for (i = 1; i <= b.length; i++) for (j = 1; j <= a.length; j++) if (b.charAt(i - 1) === a.charAt(j - 1)) matrix[i][j] = matrix[i - 1][j - 1];
|
|
30490
30554
|
else matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
|
|
30491
30555
|
return matrix[b.length][a.length];
|
|
@@ -30503,10 +30567,13 @@ compdef _{{app_name}}_yargs_completions {{app_name}}
|
|
|
30503
30567
|
const demandedCommands = yargs.getDemandedCommands();
|
|
30504
30568
|
const _s = argv._.length + (argv["--"] ? argv["--"].length : 0) - yargs.getContext().commands.length;
|
|
30505
30569
|
if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
|
|
30506
|
-
if (_s < demandedCommands._.min)
|
|
30507
|
-
|
|
30508
|
-
|
|
30509
|
-
else
|
|
30570
|
+
if (_s < demandedCommands._.min) {
|
|
30571
|
+
if (demandedCommands._.minMsg !== void 0) usage.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null);
|
|
30572
|
+
else usage.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString()));
|
|
30573
|
+
} else if (_s > demandedCommands._.max) {
|
|
30574
|
+
if (demandedCommands._.maxMsg !== void 0) usage.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null);
|
|
30575
|
+
else usage.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString()));
|
|
30576
|
+
}
|
|
30510
30577
|
}
|
|
30511
30578
|
};
|
|
30512
30579
|
self.positionalCount = function positionalCount(required, observed) {
|
|
@@ -32312,9 +32379,10 @@ var require_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
32312
32379
|
function replaceNode(key, path, node) {
|
|
32313
32380
|
const parent = path[path.length - 1];
|
|
32314
32381
|
if (identity.isCollection(parent)) parent.items[key] = node;
|
|
32315
|
-
else if (identity.isPair(parent))
|
|
32316
|
-
|
|
32317
|
-
|
|
32382
|
+
else if (identity.isPair(parent)) {
|
|
32383
|
+
if (key === "key") parent.key = node;
|
|
32384
|
+
else parent.value = node;
|
|
32385
|
+
} else if (identity.isDocument(parent)) parent.contents = node;
|
|
32318
32386
|
else {
|
|
32319
32387
|
const pt = identity.isAlias(parent) ? "alias" : "scalar";
|
|
32320
32388
|
throw new Error(`Cannot replace node with ${pt} parent`);
|
|
@@ -32565,30 +32633,32 @@ var require_applyReviver = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
32565
32633
|
* Includes extensions for handling Map and Set objects.
|
|
32566
32634
|
*/
|
|
32567
32635
|
function applyReviver(reviver, obj, key, val) {
|
|
32568
|
-
if (val && typeof val === "object")
|
|
32569
|
-
|
|
32570
|
-
|
|
32571
|
-
|
|
32572
|
-
|
|
32573
|
-
|
|
32574
|
-
|
|
32575
|
-
const
|
|
32576
|
-
|
|
32577
|
-
|
|
32578
|
-
|
|
32579
|
-
|
|
32580
|
-
|
|
32581
|
-
|
|
32582
|
-
|
|
32583
|
-
|
|
32584
|
-
|
|
32585
|
-
|
|
32586
|
-
|
|
32587
|
-
|
|
32588
|
-
|
|
32589
|
-
|
|
32590
|
-
|
|
32591
|
-
|
|
32636
|
+
if (val && typeof val === "object") {
|
|
32637
|
+
if (Array.isArray(val)) for (let i = 0, len = val.length; i < len; ++i) {
|
|
32638
|
+
const v0 = val[i];
|
|
32639
|
+
const v1 = applyReviver(reviver, val, String(i), v0);
|
|
32640
|
+
if (v1 === void 0) delete val[i];
|
|
32641
|
+
else if (v1 !== v0) val[i] = v1;
|
|
32642
|
+
}
|
|
32643
|
+
else if (val instanceof Map) for (const k of Array.from(val.keys())) {
|
|
32644
|
+
const v0 = val.get(k);
|
|
32645
|
+
const v1 = applyReviver(reviver, val, k, v0);
|
|
32646
|
+
if (v1 === void 0) val.delete(k);
|
|
32647
|
+
else if (v1 !== v0) val.set(k, v1);
|
|
32648
|
+
}
|
|
32649
|
+
else if (val instanceof Set) for (const v0 of Array.from(val)) {
|
|
32650
|
+
const v1 = applyReviver(reviver, val, v0, v0);
|
|
32651
|
+
if (v1 === void 0) val.delete(v0);
|
|
32652
|
+
else if (v1 !== v0) {
|
|
32653
|
+
val.delete(v0);
|
|
32654
|
+
val.add(v1);
|
|
32655
|
+
}
|
|
32656
|
+
}
|
|
32657
|
+
else for (const [k, v0] of Object.entries(val)) {
|
|
32658
|
+
const v1 = applyReviver(reviver, val, k, v0);
|
|
32659
|
+
if (v1 === void 0) delete val[k];
|
|
32660
|
+
else if (v1 !== v0) val[k] = v1;
|
|
32661
|
+
}
|
|
32592
32662
|
}
|
|
32593
32663
|
return reviver.call(obj, key, val);
|
|
32594
32664
|
}
|
|
@@ -33009,8 +33079,10 @@ var require_foldFlowLines = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
33009
33079
|
const folds = [];
|
|
33010
33080
|
const escapedFolds = {};
|
|
33011
33081
|
let end = lineWidth - indent.length;
|
|
33012
|
-
if (typeof indentAtStart === "number")
|
|
33013
|
-
|
|
33082
|
+
if (typeof indentAtStart === "number") {
|
|
33083
|
+
if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);
|
|
33084
|
+
else end = lineWidth - indentAtStart;
|
|
33085
|
+
}
|
|
33014
33086
|
let split = void 0;
|
|
33015
33087
|
let prev = void 0;
|
|
33016
33088
|
let overflow = false;
|
|
@@ -33047,23 +33119,25 @@ var require_foldFlowLines = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
33047
33119
|
const next = text[i + 1];
|
|
33048
33120
|
if (next && next !== " " && next !== "\n" && next !== " ") split = i;
|
|
33049
33121
|
}
|
|
33050
|
-
if (i >= end)
|
|
33051
|
-
|
|
33052
|
-
|
|
33053
|
-
|
|
33054
|
-
|
|
33055
|
-
|
|
33056
|
-
prev
|
|
33057
|
-
|
|
33058
|
-
|
|
33059
|
-
|
|
33060
|
-
|
|
33061
|
-
|
|
33062
|
-
|
|
33063
|
-
|
|
33064
|
-
|
|
33065
|
-
|
|
33066
|
-
|
|
33122
|
+
if (i >= end) {
|
|
33123
|
+
if (split) {
|
|
33124
|
+
folds.push(split);
|
|
33125
|
+
end = split + endStep;
|
|
33126
|
+
split = void 0;
|
|
33127
|
+
} else if (mode === FOLD_QUOTED) {
|
|
33128
|
+
while (prev === " " || prev === " ") {
|
|
33129
|
+
prev = ch;
|
|
33130
|
+
ch = text[i += 1];
|
|
33131
|
+
overflow = true;
|
|
33132
|
+
}
|
|
33133
|
+
const j = i > escEnd + 1 ? i - 2 : escStart - 1;
|
|
33134
|
+
if (escapedFolds[j]) return text;
|
|
33135
|
+
folds.push(j);
|
|
33136
|
+
escapedFolds[j] = true;
|
|
33137
|
+
end = j + endStep;
|
|
33138
|
+
split = void 0;
|
|
33139
|
+
} else overflow = true;
|
|
33140
|
+
}
|
|
33067
33141
|
}
|
|
33068
33142
|
prev = ch;
|
|
33069
33143
|
}
|
|
@@ -33543,8 +33617,10 @@ var require_log = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
33543
33617
|
if (logLevel === "debug") console.log(...messages);
|
|
33544
33618
|
}
|
|
33545
33619
|
function warn(logLevel, warning) {
|
|
33546
|
-
if (logLevel === "debug" || logLevel === "warn")
|
|
33547
|
-
|
|
33620
|
+
if (logLevel === "debug" || logLevel === "warn") {
|
|
33621
|
+
if (typeof node_process$2.emitWarning === "function") node_process$2.emitWarning(warning);
|
|
33622
|
+
else console.warn(warning);
|
|
33623
|
+
}
|
|
33548
33624
|
}
|
|
33549
33625
|
exports.debug = debug;
|
|
33550
33626
|
exports.warn = warn;
|
|
@@ -34371,11 +34447,12 @@ var require_pairs = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
34371
34447
|
if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable) {
|
|
34372
34448
|
if (typeof replacer === "function") it = replacer.call(iterable, String(i++), it);
|
|
34373
34449
|
let key, value;
|
|
34374
|
-
if (Array.isArray(it))
|
|
34375
|
-
|
|
34376
|
-
|
|
34377
|
-
|
|
34378
|
-
|
|
34450
|
+
if (Array.isArray(it)) {
|
|
34451
|
+
if (it.length === 2) {
|
|
34452
|
+
key = it[0];
|
|
34453
|
+
value = it[1];
|
|
34454
|
+
} else throw new TypeError(`Expected [key, value] tuple: ${it}`);
|
|
34455
|
+
} else if (it && it instanceof Object) {
|
|
34379
34456
|
const keys = Object.keys(it);
|
|
34380
34457
|
if (keys.length === 1) {
|
|
34381
34458
|
key = keys[0];
|
|
@@ -34451,8 +34528,10 @@ var require_omap = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
34451
34528
|
resolve(seq, onError) {
|
|
34452
34529
|
const pairs$1 = pairs.resolvePairs(seq, onError);
|
|
34453
34530
|
const seenKeys = [];
|
|
34454
|
-
for (const { key } of pairs$1.items) if (identity.isScalar(key))
|
|
34455
|
-
|
|
34531
|
+
for (const { key } of pairs$1.items) if (identity.isScalar(key)) {
|
|
34532
|
+
if (seenKeys.includes(key.value)) onError(`Ordered maps must not include duplicate keys: ${key.value}`);
|
|
34533
|
+
else seenKeys.push(key.value);
|
|
34534
|
+
}
|
|
34456
34535
|
return Object.assign(new YAMLOMap(), pairs$1);
|
|
34457
34536
|
},
|
|
34458
34537
|
createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
|
|
@@ -34663,9 +34742,10 @@ var require_set = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
34663
34742
|
tag: "tag:yaml.org,2002:set",
|
|
34664
34743
|
createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
|
|
34665
34744
|
resolve(map, onError) {
|
|
34666
|
-
if (identity.isMap(map))
|
|
34667
|
-
|
|
34668
|
-
|
|
34745
|
+
if (identity.isMap(map)) {
|
|
34746
|
+
if (map.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map);
|
|
34747
|
+
else onError("Set items must all have null values");
|
|
34748
|
+
} else onError("Expected a mapping for this tag");
|
|
34669
34749
|
return map;
|
|
34670
34750
|
}
|
|
34671
34751
|
};
|
|
@@ -34857,10 +34937,12 @@ var require_tags = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
34857
34937
|
const schemaTags = schemas.get(schemaName);
|
|
34858
34938
|
if (schemaTags && !customTags) return addMergeTag && !schemaTags.includes(merge.merge) ? schemaTags.concat(merge.merge) : schemaTags.slice();
|
|
34859
34939
|
let tags = schemaTags;
|
|
34860
|
-
if (!tags)
|
|
34861
|
-
|
|
34862
|
-
|
|
34863
|
-
|
|
34940
|
+
if (!tags) {
|
|
34941
|
+
if (Array.isArray(customTags)) tags = [];
|
|
34942
|
+
else {
|
|
34943
|
+
const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
|
|
34944
|
+
throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
|
|
34945
|
+
}
|
|
34864
34946
|
}
|
|
34865
34947
|
if (Array.isArray(customTags)) for (const tag of customTags) tags = tags.concat(tag);
|
|
34866
34948
|
else if (typeof customTags === "function") tags = customTags(tags.slice());
|
|
@@ -34949,14 +35031,15 @@ var require_stringifyDocument = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
34949
35031
|
if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") lines[lines.length - 1] = `--- ${body}`;
|
|
34950
35032
|
else lines.push(body);
|
|
34951
35033
|
} else lines.push(stringify.stringify(doc.contents, ctx));
|
|
34952
|
-
if (doc.directives?.docEnd)
|
|
34953
|
-
|
|
34954
|
-
|
|
34955
|
-
|
|
34956
|
-
|
|
34957
|
-
|
|
34958
|
-
|
|
34959
|
-
|
|
35034
|
+
if (doc.directives?.docEnd) {
|
|
35035
|
+
if (doc.comment) {
|
|
35036
|
+
const cs = commentString(doc.comment);
|
|
35037
|
+
if (cs.includes("\n")) {
|
|
35038
|
+
lines.push("...");
|
|
35039
|
+
lines.push(stringifyComment.indentComment(cs, ""));
|
|
35040
|
+
} else lines.push(`... ${cs}`);
|
|
35041
|
+
} else lines.push("...");
|
|
35042
|
+
} else {
|
|
34960
35043
|
let dc = doc.comment;
|
|
34961
35044
|
if (dc && chompKeep) dc = dc.replace(/^\n+/, "");
|
|
34962
35045
|
if (dc) {
|
|
@@ -35495,8 +35578,10 @@ var require_resolve_block_map = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
35495
35578
|
}
|
|
35496
35579
|
if (!keyProps.anchor && !keyProps.tag && !sep) {
|
|
35497
35580
|
commentEnd = keyProps.end;
|
|
35498
|
-
if (keyProps.comment)
|
|
35499
|
-
|
|
35581
|
+
if (keyProps.comment) {
|
|
35582
|
+
if (map.comment) map.comment += "\n" + keyProps.comment;
|
|
35583
|
+
else map.comment = keyProps.comment;
|
|
35584
|
+
}
|
|
35500
35585
|
continue;
|
|
35501
35586
|
}
|
|
35502
35587
|
if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key)) onError(key ?? start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
|
|
@@ -35529,8 +35614,10 @@ var require_resolve_block_map = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
35529
35614
|
map.items.push(pair);
|
|
35530
35615
|
} else {
|
|
35531
35616
|
if (implicitKey) onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values");
|
|
35532
|
-
if (valueProps.comment)
|
|
35533
|
-
|
|
35617
|
+
if (valueProps.comment) {
|
|
35618
|
+
if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
|
|
35619
|
+
else keyNode.comment = valueProps.comment;
|
|
35620
|
+
}
|
|
35534
35621
|
const pair = new Pair.Pair(keyNode);
|
|
35535
35622
|
if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
|
|
35536
35623
|
map.items.push(pair);
|
|
@@ -35567,12 +35654,15 @@ var require_resolve_block_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
35567
35654
|
parentIndent: bs.indent,
|
|
35568
35655
|
startOnNewline: true
|
|
35569
35656
|
});
|
|
35570
|
-
if (!props.found)
|
|
35571
|
-
|
|
35572
|
-
|
|
35573
|
-
|
|
35574
|
-
|
|
35575
|
-
|
|
35657
|
+
if (!props.found) {
|
|
35658
|
+
if (props.anchor || props.tag || value) {
|
|
35659
|
+
if (value?.type === "block-seq") onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
|
|
35660
|
+
else onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
|
|
35661
|
+
} else {
|
|
35662
|
+
commentEnd = props.end;
|
|
35663
|
+
if (props.comment) seq.comment = props.comment;
|
|
35664
|
+
continue;
|
|
35665
|
+
}
|
|
35576
35666
|
}
|
|
35577
35667
|
const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
|
|
35578
35668
|
if (ctx.schema.compat) utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError);
|
|
@@ -35664,8 +35754,10 @@ var require_resolve_flow_collection = /* @__PURE__ */ __commonJSMin(((exports) =
|
|
|
35664
35754
|
if (!props.anchor && !props.tag && !sep && !value) {
|
|
35665
35755
|
if (i === 0 && props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
|
|
35666
35756
|
else if (i < fc.items.length - 1) onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
|
|
35667
|
-
if (props.comment)
|
|
35668
|
-
|
|
35757
|
+
if (props.comment) {
|
|
35758
|
+
if (coll.comment) coll.comment += "\n" + props.comment;
|
|
35759
|
+
else coll.comment = props.comment;
|
|
35760
|
+
}
|
|
35669
35761
|
offset = props.end;
|
|
35670
35762
|
continue;
|
|
35671
35763
|
}
|
|
@@ -35725,13 +35817,17 @@ var require_resolve_flow_collection = /* @__PURE__ */ __commonJSMin(((exports) =
|
|
|
35725
35817
|
}
|
|
35726
35818
|
if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
|
|
35727
35819
|
}
|
|
35728
|
-
} else if (value)
|
|
35729
|
-
|
|
35820
|
+
} else if (value) {
|
|
35821
|
+
if ("source" in value && value.source?.[0] === ":") onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`);
|
|
35822
|
+
else onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
|
|
35823
|
+
}
|
|
35730
35824
|
const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
|
|
35731
35825
|
if (valueNode) {
|
|
35732
35826
|
if (isBlock(value)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
|
|
35733
|
-
} else if (valueProps.comment)
|
|
35734
|
-
|
|
35827
|
+
} else if (valueProps.comment) {
|
|
35828
|
+
if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
|
|
35829
|
+
else keyNode.comment = valueProps.comment;
|
|
35830
|
+
}
|
|
35735
35831
|
const pair = new Pair.Pair(keyNode, valueNode);
|
|
35736
35832
|
if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
|
|
35737
35833
|
if (isMap) {
|
|
@@ -35765,8 +35861,10 @@ var require_resolve_flow_collection = /* @__PURE__ */ __commonJSMin(((exports) =
|
|
|
35765
35861
|
}
|
|
35766
35862
|
if (ee.length > 0) {
|
|
35767
35863
|
const end = resolveEnd.resolveEnd(ee, cePos, ctx.options.strict, onError);
|
|
35768
|
-
if (end.comment)
|
|
35769
|
-
|
|
35864
|
+
if (end.comment) {
|
|
35865
|
+
if (coll.comment) coll.comment += "\n" + end.comment;
|
|
35866
|
+
else coll.comment = end.comment;
|
|
35867
|
+
}
|
|
35770
35868
|
coll.range = [
|
|
35771
35869
|
fc.offset,
|
|
35772
35870
|
cePos,
|
|
@@ -35914,9 +36012,10 @@ var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
35914
36012
|
value += sep + indent.slice(trimIndent) + content;
|
|
35915
36013
|
sep = "\n";
|
|
35916
36014
|
prevMoreIndented = true;
|
|
35917
|
-
} else if (content === "")
|
|
35918
|
-
|
|
35919
|
-
|
|
36015
|
+
} else if (content === "") {
|
|
36016
|
+
if (sep === "\n") value += "\n";
|
|
36017
|
+
else sep = "\n";
|
|
36018
|
+
} else {
|
|
35920
36019
|
value += sep + content;
|
|
35921
36020
|
sep = " ";
|
|
35922
36021
|
prevMoreIndented = false;
|
|
@@ -36109,9 +36208,10 @@ var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
36109
36208
|
let pos = first.lastIndex;
|
|
36110
36209
|
line.lastIndex = pos;
|
|
36111
36210
|
while (match = line.exec(source)) {
|
|
36112
|
-
if (match[1] === "")
|
|
36113
|
-
|
|
36114
|
-
|
|
36211
|
+
if (match[1] === "") {
|
|
36212
|
+
if (sep === "\n") res += sep;
|
|
36213
|
+
else sep = "\n";
|
|
36214
|
+
} else {
|
|
36115
36215
|
res += sep + match[1];
|
|
36116
36216
|
sep = " ";
|
|
36117
36217
|
}
|
|
@@ -36247,8 +36347,10 @@ var require_compose_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
36247
36347
|
function findScalarTagByName(schema, value, tagName, tagToken, onError) {
|
|
36248
36348
|
if (tagName === "!") return schema[identity.SCALAR];
|
|
36249
36349
|
const matchWithTest = [];
|
|
36250
|
-
for (const tag of schema.tags) if (!tag.collection && tag.tag === tagName)
|
|
36251
|
-
|
|
36350
|
+
for (const tag of schema.tags) if (!tag.collection && tag.tag === tagName) {
|
|
36351
|
+
if (tag.default && tag.test) matchWithTest.push(tag);
|
|
36352
|
+
else return tag;
|
|
36353
|
+
}
|
|
36252
36354
|
for (const tag of matchWithTest) if (tag.test?.test(value)) return tag;
|
|
36253
36355
|
const kt = schema.knownTags[tagName];
|
|
36254
36356
|
if (kt && !kt.collection) {
|
|
@@ -36346,8 +36448,10 @@ var require_compose_node = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
36346
36448
|
if (anchor && node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
|
|
36347
36449
|
if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) onError(tag ?? token, "NON_STRING_KEY", "With stringKeys, all keys must be strings");
|
|
36348
36450
|
if (spaceBefore) node.spaceBefore = true;
|
|
36349
|
-
if (comment)
|
|
36350
|
-
|
|
36451
|
+
if (comment) {
|
|
36452
|
+
if (token.type === "scalar" && token.source === "") node.comment = comment;
|
|
36453
|
+
else node.commentBefore = comment;
|
|
36454
|
+
}
|
|
36351
36455
|
if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token;
|
|
36352
36456
|
return node;
|
|
36353
36457
|
}
|
|
@@ -37536,11 +37640,13 @@ var require_lexer = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
37536
37640
|
end = i;
|
|
37537
37641
|
} else if (isEmpty(ch)) {
|
|
37538
37642
|
let next = this.buffer[i + 1];
|
|
37539
|
-
if (ch === "\r")
|
|
37540
|
-
|
|
37541
|
-
|
|
37542
|
-
|
|
37543
|
-
|
|
37643
|
+
if (ch === "\r") {
|
|
37644
|
+
if (next === "\n") {
|
|
37645
|
+
i += 1;
|
|
37646
|
+
ch = "\n";
|
|
37647
|
+
next = this.buffer[i + 1];
|
|
37648
|
+
} else end = i;
|
|
37649
|
+
}
|
|
37544
37650
|
if (next === "#" || inFlow && flowIndicatorChars.has(next)) break;
|
|
37545
37651
|
if (ch === "\n") {
|
|
37546
37652
|
const cs = this.continueScalar(i + 1);
|
|
@@ -37757,9 +37863,10 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
37757
37863
|
for (const it of fc.items) if (it.sep && !it.value && !includesToken(it.start, "explicit-key-ind") && !includesToken(it.sep, "map-value-ind")) {
|
|
37758
37864
|
if (it.key) it.value = it.key;
|
|
37759
37865
|
delete it.key;
|
|
37760
|
-
if (isFlowToken(it.value))
|
|
37761
|
-
|
|
37762
|
-
|
|
37866
|
+
if (isFlowToken(it.value)) {
|
|
37867
|
+
if (it.value.end) arrayPushArray(it.value.end, it.sep);
|
|
37868
|
+
else it.value.end = it.sep;
|
|
37869
|
+
} else arrayPushArray(it.start, it.sep);
|
|
37763
37870
|
delete it.sep;
|
|
37764
37871
|
}
|
|
37765
37872
|
}
|
|
@@ -38194,58 +38301,60 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
38194
38301
|
this.onKeyLine = true;
|
|
38195
38302
|
return;
|
|
38196
38303
|
case "map-value-ind":
|
|
38197
|
-
if (it.explicitKey)
|
|
38198
|
-
|
|
38199
|
-
|
|
38200
|
-
});
|
|
38201
|
-
else {
|
|
38202
|
-
const start = getFirstKeyStartProps(it.start);
|
|
38203
|
-
this.stack.push({
|
|
38204
|
-
type: "block-map",
|
|
38205
|
-
offset: this.offset,
|
|
38206
|
-
indent: this.indent,
|
|
38207
|
-
items: [{
|
|
38208
|
-
start,
|
|
38304
|
+
if (it.explicitKey) {
|
|
38305
|
+
if (!it.sep) {
|
|
38306
|
+
if (includesToken(it.start, "newline")) Object.assign(it, {
|
|
38209
38307
|
key: null,
|
|
38210
38308
|
sep: [this.sourceToken]
|
|
38211
|
-
}
|
|
38212
|
-
|
|
38213
|
-
|
|
38214
|
-
|
|
38215
|
-
|
|
38216
|
-
|
|
38217
|
-
|
|
38218
|
-
|
|
38219
|
-
|
|
38220
|
-
|
|
38221
|
-
|
|
38222
|
-
|
|
38223
|
-
|
|
38224
|
-
|
|
38309
|
+
});
|
|
38310
|
+
else {
|
|
38311
|
+
const start = getFirstKeyStartProps(it.start);
|
|
38312
|
+
this.stack.push({
|
|
38313
|
+
type: "block-map",
|
|
38314
|
+
offset: this.offset,
|
|
38315
|
+
indent: this.indent,
|
|
38316
|
+
items: [{
|
|
38317
|
+
start,
|
|
38318
|
+
key: null,
|
|
38319
|
+
sep: [this.sourceToken]
|
|
38320
|
+
}]
|
|
38321
|
+
});
|
|
38322
|
+
}
|
|
38323
|
+
} else if (it.value) map.items.push({
|
|
38324
|
+
start: [],
|
|
38225
38325
|
key: null,
|
|
38226
38326
|
sep: [this.sourceToken]
|
|
38227
|
-
}
|
|
38228
|
-
|
|
38229
|
-
else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
|
|
38230
|
-
const start = getFirstKeyStartProps(it.start);
|
|
38231
|
-
const key = it.key;
|
|
38232
|
-
const sep = it.sep;
|
|
38233
|
-
sep.push(this.sourceToken);
|
|
38234
|
-
delete it.key;
|
|
38235
|
-
delete it.sep;
|
|
38236
|
-
this.stack.push({
|
|
38327
|
+
});
|
|
38328
|
+
else if (includesToken(it.sep, "map-value-ind")) this.stack.push({
|
|
38237
38329
|
type: "block-map",
|
|
38238
38330
|
offset: this.offset,
|
|
38239
38331
|
indent: this.indent,
|
|
38240
38332
|
items: [{
|
|
38241
38333
|
start,
|
|
38242
|
-
key,
|
|
38243
|
-
sep
|
|
38334
|
+
key: null,
|
|
38335
|
+
sep: [this.sourceToken]
|
|
38244
38336
|
}]
|
|
38245
38337
|
});
|
|
38246
|
-
|
|
38247
|
-
|
|
38248
|
-
|
|
38338
|
+
else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
|
|
38339
|
+
const start = getFirstKeyStartProps(it.start);
|
|
38340
|
+
const key = it.key;
|
|
38341
|
+
const sep = it.sep;
|
|
38342
|
+
sep.push(this.sourceToken);
|
|
38343
|
+
delete it.key;
|
|
38344
|
+
delete it.sep;
|
|
38345
|
+
this.stack.push({
|
|
38346
|
+
type: "block-map",
|
|
38347
|
+
offset: this.offset,
|
|
38348
|
+
indent: this.indent,
|
|
38349
|
+
items: [{
|
|
38350
|
+
start,
|
|
38351
|
+
key,
|
|
38352
|
+
sep
|
|
38353
|
+
}]
|
|
38354
|
+
});
|
|
38355
|
+
} else if (start.length > 0) it.sep = it.sep.concat(start, this.sourceToken);
|
|
38356
|
+
else it.sep.push(this.sourceToken);
|
|
38357
|
+
} else if (!it.sep) Object.assign(it, {
|
|
38249
38358
|
key: null,
|
|
38250
38359
|
sep: [this.sourceToken]
|
|
38251
38360
|
});
|
|
@@ -38618,8 +38727,10 @@ var require_public_api = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
38618
38727
|
const doc = parseDocument(src, options);
|
|
38619
38728
|
if (!doc) return null;
|
|
38620
38729
|
doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning));
|
|
38621
|
-
if (doc.errors.length > 0)
|
|
38622
|
-
|
|
38730
|
+
if (doc.errors.length > 0) {
|
|
38731
|
+
if (doc.options.logLevel !== "silent") throw doc.errors[0];
|
|
38732
|
+
else doc.errors = [];
|
|
38733
|
+
}
|
|
38623
38734
|
return doc.toJS(Object.assign({ reviver: _reviver }, options));
|
|
38624
38735
|
}
|
|
38625
38736
|
function stringify(value, replacer, options) {
|
|
@@ -42887,14 +42998,15 @@ function getCurrentVersionString(inputs) {
|
|
|
42887
42998
|
const actionDir = path$2.dirname(inputs.action.path);
|
|
42888
42999
|
log.debug(`version source: ${versionSource}`);
|
|
42889
43000
|
let detectedVersion;
|
|
42890
|
-
if (versionSource === "explicit")
|
|
42891
|
-
|
|
42892
|
-
|
|
43001
|
+
if (versionSource === "explicit") {
|
|
43002
|
+
if (override && override.length > 0) {
|
|
43003
|
+
detectedVersion = override;
|
|
43004
|
+
log.debug(`using explicit version override: ${detectedVersion}`);
|
|
43005
|
+
} else {
|
|
43006
|
+
log.debug("explicit mode but no version_override set, falling back to 0.0.0");
|
|
43007
|
+
detectedVersion = "0.0.0";
|
|
43008
|
+
}
|
|
42893
43009
|
} else {
|
|
42894
|
-
log.debug("explicit mode but no version_override set, falling back to 0.0.0");
|
|
42895
|
-
detectedVersion = "0.0.0";
|
|
42896
|
-
}
|
|
42897
|
-
else {
|
|
42898
43010
|
switch (versionSource) {
|
|
42899
43011
|
case "git-branch":
|
|
42900
43012
|
detectedVersion = getVersionFromGitBranch(actionDir, log);
|
|
@@ -43002,7 +43114,7 @@ var Fo$2 = q$2((x8, ko) => {
|
|
|
43002
43114
|
return !!(e && e.prototype && e.prototype.visitors);
|
|
43003
43115
|
}
|
|
43004
43116
|
function vg(e, t) {
|
|
43005
|
-
for (var r = t || {}, n = e.prototype, a = n.blockTokenizers, u = n.inlineTokenizers, i = n.blockMethods, o = n.inlineMethods, s = a.definition, l = u.reference, c = [], f = -1, h = i.length, m; ++f < h;) m = i[f],
|
|
43117
|
+
for (var r = t || {}, n = e.prototype, a = n.blockTokenizers, u = n.inlineTokenizers, i = n.blockMethods, o = n.inlineMethods, s = a.definition, l = u.reference, c = [], f = -1, h = i.length, m; ++f < h;) m = i[f], m !== "newline" && m !== "indentedCode" && m !== "paragraph" && m !== "footnoteDefinition" && c.push([m]);
|
|
43006
43118
|
c.push(["footnoteDefinition"]), r.inlineNotes && (Oi(o, "reference", "inlineNote"), u.inlineNote = g), Oi(i, "definition", "footnoteDefinition"), Oi(o, "reference", "footnoteCall"), a.definition = E, a.footnoteDefinition = D, u.footnoteCall = x, u.reference = k, n.interruptFootnoteDefinition = c, k.locator = l.locator, x.locator = C, g.locator = S;
|
|
43007
43119
|
function D(w, d, v) {
|
|
43008
43120
|
for (var L = this, y = L.interruptFootnoteDefinition, b = L.offset, _ = d.length + 1, I = 0, T = [], R, O, z, N, W, ne, p, Y, ie, F, ee, ce, te; I < _ && (N = d.charCodeAt(I), !(N !== sr && N !== _t));) I++;
|
|
@@ -46484,13 +46596,13 @@ var kl = q$2((uT, xl) => {
|
|
|
46484
46596
|
var gl = `
|
|
46485
46597
|
`, N1 = " ", R1 = "!";
|
|
46486
46598
|
function M1(e, t) {
|
|
46487
|
-
var r = e.split(gl), n = r.length + 1, a =
|
|
46599
|
+
var r = e.split(gl), n = r.length + 1, a = 1 / 0, u = [], i, o, s;
|
|
46488
46600
|
for (r.unshift(P1(N1, t) + R1); n--;) if (o = O1(r[n]), u[n] = o.stops, _1(r[n]).length !== 0) if (o.indent) o.indent > 0 && o.indent < a && (a = o.indent);
|
|
46489
46601
|
else {
|
|
46490
|
-
a =
|
|
46602
|
+
a = 1 / 0;
|
|
46491
46603
|
break;
|
|
46492
46604
|
}
|
|
46493
|
-
if (a !==
|
|
46605
|
+
if (a !== 1 / 0) for (n = r.length; n--;) {
|
|
46494
46606
|
for (s = u[n], i = a; i && !(i in s);) i--;
|
|
46495
46607
|
r[n] = r[n].slice(s[i] + 1);
|
|
46496
46608
|
}
|
|
@@ -47346,7 +47458,7 @@ var Ef = q$2((UT, bf) => {
|
|
|
47346
47458
|
function PF(e, t, r) {
|
|
47347
47459
|
var n = this, a, u, i, o, s, l, c, f, h, m;
|
|
47348
47460
|
if (r) return !0;
|
|
47349
|
-
for (a = n.inlineMethods, o = a.length, u = n.inlineTokenizers, i = -1, h = t.length; ++i < o;) f = a[i],
|
|
47461
|
+
for (a = n.inlineMethods, o = a.length, u = n.inlineTokenizers, i = -1, h = t.length; ++i < o;) f = a[i], f !== "text" && u[f] && (c = u[f].locator, c || e.file.fail("Missing locator: `" + f + "`"), l = c.call(n, t, 1), l !== -1 && l < h && (h = l));
|
|
47350
47462
|
s = t.slice(0, h), m = e.now(), n.decode(s, m, D);
|
|
47351
47463
|
function D(x, g, k) {
|
|
47352
47464
|
e(k || x)({
|
|
@@ -47850,7 +47962,7 @@ var wp = q$2((n3, Ep) => {
|
|
|
47850
47962
|
var g, k;
|
|
47851
47963
|
if (a) return u;
|
|
47852
47964
|
for (; ++n < e.length;) g = e[n], g[1] !== !1 && (g[1] === !0 && (g[1] = void 0), k = g[0].apply(u, g.slice(1)), typeof k == "function" && t.use(k));
|
|
47853
|
-
return a = !0, n =
|
|
47965
|
+
return a = !0, n = 1 / 0, u;
|
|
47854
47966
|
}
|
|
47855
47967
|
function o(g, k) {
|
|
47856
47968
|
return typeof g == "string" ? arguments.length === 2 ? (za("data", a), r[g] = k, u) : bb.call(r, g) && r[g] || null : g ? (za("data", a), r = g, u) : r;
|
|
@@ -56575,16 +56687,13 @@ function ME(e, t, r) {
|
|
|
56575
56687
|
offset: o.position.end.offset
|
|
56576
56688
|
});
|
|
56577
56689
|
break;
|
|
56578
|
-
case "end":
|
|
56579
|
-
a
|
|
56580
|
-
|
|
56581
|
-
|
|
56582
|
-
|
|
56583
|
-
|
|
56584
|
-
|
|
56585
|
-
}), a = null);
|
|
56586
|
-
break;
|
|
56587
|
-
default: break;
|
|
56690
|
+
case "end": a !== null && (n.push({
|
|
56691
|
+
start: a,
|
|
56692
|
+
end: {
|
|
56693
|
+
index: i,
|
|
56694
|
+
offset: o.position.start.offset
|
|
56695
|
+
}
|
|
56696
|
+
}), a = null);
|
|
56588
56697
|
}
|
|
56589
56698
|
return ae$2(e, t, r, { processor({ index: i }) {
|
|
56590
56699
|
if (n.length > 0) {
|
|
@@ -60949,7 +61058,7 @@ function Pa(t, e) {
|
|
|
60949
61058
|
let i = s, o = t[s + 1];
|
|
60950
61059
|
for (; o === " " || o === " ";) o = t[++s + 1];
|
|
60951
61060
|
o !== `
|
|
60952
|
-
` &&
|
|
61061
|
+
` && (o !== "\r" || t[s + 2] !== `
|
|
60953
61062
|
`) && (n += s > i ? t.slice(i, s + 1) : r);
|
|
60954
61063
|
} else n += r;
|
|
60955
61064
|
}
|
|
@@ -63240,12 +63349,12 @@ var Ne = class {
|
|
|
63240
63349
|
} else return C;
|
|
63241
63350
|
}, D = r.length, s = e.length, a = 1, c = D + s;
|
|
63242
63351
|
n.maxEditLength != null && (c = Math.min(c, n.maxEditLength));
|
|
63243
|
-
let p = (o = n.timeout) !== null && o !== void 0 ? o :
|
|
63352
|
+
let p = (o = n.timeout) !== null && o !== void 0 ? o : 1 / 0, l = Date.now() + p, m = [{
|
|
63244
63353
|
oldPos: -1,
|
|
63245
63354
|
lastComponent: void 0
|
|
63246
63355
|
}], f = this.extractCommon(m[0], r, e, 0, n);
|
|
63247
63356
|
if (m[0].oldPos + 1 >= s && f + 1 >= D) return i(this.buildValues(m[0].lastComponent, r, e));
|
|
63248
|
-
let F = -
|
|
63357
|
+
let F = -1 / 0, d = 1 / 0, E = () => {
|
|
63249
63358
|
for (let C = Math.max(F, -a); C <= Math.min(d, a); C += 2) {
|
|
63250
63359
|
let h, _ = m[C - 1], P = m[C + 1];
|
|
63251
63360
|
_ && (m[C - 1] = void 0);
|
|
@@ -65004,7 +65113,7 @@ var Fn = {
|
|
|
65004
65113
|
default: -1,
|
|
65005
65114
|
range: {
|
|
65006
65115
|
start: -1,
|
|
65007
|
-
end:
|
|
65116
|
+
end: 1 / 0,
|
|
65008
65117
|
step: 1
|
|
65009
65118
|
},
|
|
65010
65119
|
description: "Print (to stderr) where a cursor at the given position would move to after formatting.",
|
|
@@ -65176,17 +65285,17 @@ var Fn = {
|
|
|
65176
65285
|
description: "The line length where Prettier will try wrap.",
|
|
65177
65286
|
range: {
|
|
65178
65287
|
start: 0,
|
|
65179
|
-
end:
|
|
65288
|
+
end: 1 / 0,
|
|
65180
65289
|
step: 1
|
|
65181
65290
|
}
|
|
65182
65291
|
},
|
|
65183
65292
|
rangeEnd: {
|
|
65184
65293
|
category: "Special",
|
|
65185
65294
|
type: "int",
|
|
65186
|
-
default:
|
|
65295
|
+
default: 1 / 0,
|
|
65187
65296
|
range: {
|
|
65188
65297
|
start: 0,
|
|
65189
|
-
end:
|
|
65298
|
+
end: 1 / 0,
|
|
65190
65299
|
step: 1
|
|
65191
65300
|
},
|
|
65192
65301
|
description: `Format code ending at a given character offset (exclusive).
|
|
@@ -65199,7 +65308,7 @@ The range will extend forwards to the end of the selected statement.`,
|
|
|
65199
65308
|
default: 0,
|
|
65200
65309
|
range: {
|
|
65201
65310
|
start: 0,
|
|
65202
|
-
end:
|
|
65311
|
+
end: 1 / 0,
|
|
65203
65312
|
step: 1
|
|
65204
65313
|
},
|
|
65205
65314
|
description: `Format code starting at a given character offset.
|
|
@@ -65220,7 +65329,7 @@ The range will extend backwards to the start of the first line containing the se
|
|
|
65220
65329
|
description: "Number of spaces per indentation level.",
|
|
65221
65330
|
range: {
|
|
65222
65331
|
start: 0,
|
|
65223
|
-
end:
|
|
65332
|
+
end: 1 / 0,
|
|
65224
65333
|
step: 1
|
|
65225
65334
|
}
|
|
65226
65335
|
},
|
|
@@ -66450,6 +66559,8 @@ function iu(t, e, r) {
|
|
|
66450
66559
|
case "meriyah":
|
|
66451
66560
|
case "oxc":
|
|
66452
66561
|
case "oxc-ts":
|
|
66562
|
+
case "yuku":
|
|
66563
|
+
case "yuku-ts":
|
|
66453
66564
|
case "__babel_estree": return Fi(e.type, r?.type);
|
|
66454
66565
|
case "json":
|
|
66455
66566
|
case "json5":
|
|
@@ -66674,7 +66785,7 @@ var Ai = {
|
|
|
66674
66785
|
replaceEndOfLine: Nr,
|
|
66675
66786
|
canBreak: wr
|
|
66676
66787
|
};
|
|
66677
|
-
var gu = "3.9.
|
|
66788
|
+
var gu = "3.9.6";
|
|
66678
66789
|
var fr = {};
|
|
66679
66790
|
yt(fr, {
|
|
66680
66791
|
addDanglingComment: () => re,
|
|
@@ -66912,14 +67023,51 @@ const startTokenFormat = "(^|[^`\\\\])<!--\\s+start\\s+%s\\s+-->";
|
|
|
66912
67023
|
* The format for the end token of a section.
|
|
66913
67024
|
*/
|
|
66914
67025
|
const endTokenFormat = "(^|[^`\\\\])<!--\\s+end\\s+%s\\s+-->";
|
|
67026
|
+
/**
|
|
67027
|
+
* Lays out section content the way it sits between its markers.
|
|
67028
|
+
* @param {string} content - The trimmed section content.
|
|
67029
|
+
* @param {boolean} addNewlines - Whether to pad the content with newlines.
|
|
67030
|
+
* @returns {string} - The text that goes between the markers.
|
|
67031
|
+
*/
|
|
67032
|
+
function layoutSpan(content, addNewlines) {
|
|
67033
|
+
return addNewlines ? `\n\n${content}\n` : content;
|
|
67034
|
+
}
|
|
67035
|
+
/**
|
|
67036
|
+
* True when every line break in `text` is CRLF, and there is at least one.
|
|
67037
|
+
*
|
|
67038
|
+
* Only a document that is CRLF throughout is edited as CRLF. Removing the `\r`
|
|
67039
|
+
* before each `\n` and adding it back is then an exact round trip, so the
|
|
67040
|
+
* bytes outside the markers survive. A document that mixes the two is left as
|
|
67041
|
+
* it is, since no single ending would reproduce it.
|
|
67042
|
+
* @param {string} text - The document.
|
|
67043
|
+
* @returns {boolean} - Whether the document uses CRLF line endings.
|
|
67044
|
+
*/
|
|
67045
|
+
function usesCrlf(text) {
|
|
67046
|
+
return text.includes("\r\n") && !/(^|[^\r])\n/.test(text);
|
|
67047
|
+
}
|
|
66915
67048
|
var ReadmeEditor = class {
|
|
66916
67049
|
log = new LogTask("ReadmeEditor");
|
|
66917
67050
|
/**
|
|
66918
67051
|
* The path to the README file.
|
|
66919
67052
|
*/
|
|
66920
67053
|
filePath;
|
|
67054
|
+
/**
|
|
67055
|
+
* The document with LF line endings, whatever the file uses. Every edit and
|
|
67056
|
+
* every formatter pass works on LF; `dumpToFile` restores the file's own
|
|
67057
|
+
* ending on the way out.
|
|
67058
|
+
*/
|
|
66921
67059
|
fileContent;
|
|
66922
67060
|
/**
|
|
67061
|
+
* Whether the file on disk is CRLF throughout — see `usesCrlf`.
|
|
67062
|
+
*/
|
|
67063
|
+
crlf = false;
|
|
67064
|
+
/**
|
|
67065
|
+
* The padded sections this editor has replaced, each against the content it
|
|
67066
|
+
* wrote. `dumpToFile` formats these spans and nothing else — see
|
|
67067
|
+
* `formatUpdatedSections`.
|
|
67068
|
+
*/
|
|
67069
|
+
updatedSections = /* @__PURE__ */ new Map();
|
|
67070
|
+
/**
|
|
66923
67071
|
* Creates a new instance of `ReadmeEditor`.
|
|
66924
67072
|
* @param {string} filePath - The path to the README file.
|
|
66925
67073
|
*/
|
|
@@ -66927,15 +67075,17 @@ var ReadmeEditor = class {
|
|
|
66927
67075
|
this.filePath = filePath;
|
|
66928
67076
|
try {
|
|
66929
67077
|
fs$3.accessSync(filePath);
|
|
66930
|
-
|
|
66931
|
-
if (process.env.GITHUB_ACTIONS) setOutput("readme_before",
|
|
67078
|
+
const raw = fs$3.readFileSync(filePath, "utf8");
|
|
67079
|
+
if (process.env.GITHUB_ACTIONS) setOutput("readme_before", raw);
|
|
67080
|
+
this.crlf = usesCrlf(raw);
|
|
67081
|
+
this.fileContent = this.crlf ? raw.replaceAll("\r\n", "\n") : raw;
|
|
66932
67082
|
} catch (error) {
|
|
66933
67083
|
this.log.fail(`Readme at '${filePath}' does not exist.`);
|
|
66934
67084
|
throw error;
|
|
66935
67085
|
}
|
|
66936
67086
|
}
|
|
66937
67087
|
/**
|
|
66938
|
-
* Gets the current README content.
|
|
67088
|
+
* Gets the current README content, with LF line endings.
|
|
66939
67089
|
* @returns {string} - The README file content.
|
|
66940
67090
|
*/
|
|
66941
67091
|
getReadmeContent() {
|
|
@@ -66970,24 +67120,66 @@ var ReadmeEditor = class {
|
|
|
66970
67120
|
*/
|
|
66971
67121
|
updateSection(name, providedContent, addNewlines = true) {
|
|
66972
67122
|
const log = new LogTask(name);
|
|
66973
|
-
const content = (Array.isArray(providedContent) ? providedContent.join(
|
|
67123
|
+
const content = (Array.isArray(providedContent) ? providedContent.join("\n") : providedContent ?? "").replaceAll("\r\n", "\n").trim();
|
|
66974
67124
|
log.info(`Looking for the ${name} token in ${this.filePath}`);
|
|
66975
67125
|
const [startIndex, stopIndex] = this.getTokenIndexes(name, log);
|
|
66976
67126
|
if (startIndex && stopIndex) {
|
|
66977
67127
|
const beforeContent = this.fileContent.slice(0, startIndex);
|
|
66978
67128
|
const afterContent = this.fileContent.slice(stopIndex);
|
|
66979
|
-
this.fileContent =
|
|
67129
|
+
this.fileContent = `${beforeContent}${layoutSpan(content, addNewlines)}${afterContent}`;
|
|
67130
|
+
if (addNewlines) this.updatedSections.set(name, content);
|
|
67131
|
+
}
|
|
67132
|
+
}
|
|
67133
|
+
/**
|
|
67134
|
+
* Formats the span of one section in isolation and splices it back.
|
|
67135
|
+
*
|
|
67136
|
+
* The content is formatted on its own and reassembled with the same
|
|
67137
|
+
* surrounding newlines `updateSection` wrote, so the markers and every byte
|
|
67138
|
+
* outside them survive untouched.
|
|
67139
|
+
*
|
|
67140
|
+
* The span is formatted only while its markers still bound exactly the text
|
|
67141
|
+
* `updateSection` wrote. The markers are paired again here, after every
|
|
67142
|
+
* section has been written, and a marker another section wrote can win that
|
|
67143
|
+
* pairing; the text between such a pair is not this tool's to format.
|
|
67144
|
+
* @param {string} name - The name of the section.
|
|
67145
|
+
* @param {string} content - The content `updateSection` wrote, padded.
|
|
67146
|
+
*/
|
|
67147
|
+
async formatSection(name, content) {
|
|
67148
|
+
const [startIndex, stopIndex] = this.getTokenIndexes(name);
|
|
67149
|
+
if (!startIndex || !stopIndex) return;
|
|
67150
|
+
if (startIndex > stopIndex || this.fileContent.slice(startIndex, stopIndex) !== layoutSpan(content, true)) {
|
|
67151
|
+
this.log.warn(`The '${name}' markers no longer bound the text written to them. Leaving the section unformatted`);
|
|
67152
|
+
return;
|
|
66980
67153
|
}
|
|
67154
|
+
const formatted = content === "" ? "" : (await formatMarkdown(content)).trim();
|
|
67155
|
+
const span = formatted === "" ? "\n" : layoutSpan(formatted, true);
|
|
67156
|
+
this.fileContent = `${this.fileContent.slice(0, startIndex)}${span}${this.fileContent.slice(stopIndex)}`;
|
|
67157
|
+
}
|
|
67158
|
+
/**
|
|
67159
|
+
* Formats every span this editor replaced, one span at a time.
|
|
67160
|
+
*
|
|
67161
|
+
* Each span is located again before it is formatted, because formatting the
|
|
67162
|
+
* previous one moves the indexes of the spans after it. A formatted span no
|
|
67163
|
+
* longer holds the text `updateSection` wrote, so it is forgotten once
|
|
67164
|
+
* formatted.
|
|
67165
|
+
* @returns {Promise<void>}
|
|
67166
|
+
*/
|
|
67167
|
+
async formatUpdatedSections() {
|
|
67168
|
+
for (const [name, content] of this.updatedSections) await this.formatSection(name, content);
|
|
67169
|
+
this.updatedSections.clear();
|
|
66981
67170
|
}
|
|
66982
67171
|
/**
|
|
66983
67172
|
* Dumps the modified content back to the README file.
|
|
66984
|
-
* @param {boolean} [prettier=true] - Run the
|
|
66985
|
-
* writing. Callers pass the resolved `pretty` input; it defaults to
|
|
66986
|
-
* constructing a ReadmeEditor directly keeps the formatting
|
|
67173
|
+
* @param {boolean} [prettier=true] - Run the replaced spans through prettier
|
|
67174
|
+
* before writing. Callers pass the resolved `pretty` input; it defaults to
|
|
67175
|
+
* true so constructing a ReadmeEditor directly keeps the formatting
|
|
67176
|
+
* behaviour. Text outside the markers is never formatted, whatever this
|
|
67177
|
+
* flag says — see `docs/tool-contract.md`.
|
|
66987
67178
|
* @returns {Promise<void>}
|
|
66988
67179
|
*/
|
|
66989
67180
|
async dumpToFile(prettier = true) {
|
|
66990
|
-
|
|
67181
|
+
if (prettier) await this.formatUpdatedSections();
|
|
67182
|
+
const content = this.crlf ? this.fileContent.replaceAll("\n", "\r\n") : this.fileContent;
|
|
66991
67183
|
if (process.env.GITHUB_ACTIONS) setOutput("readme_after", content);
|
|
66992
67184
|
return fs$3.promises.writeFile(this.filePath, content, "utf8");
|
|
66993
67185
|
}
|
|
@@ -67546,10 +67738,12 @@ function loadConfig(log, providedConfig, configFilePath) {
|
|
|
67546
67738
|
const config = providedConfig ?? new import_nconf.Provider();
|
|
67547
67739
|
if (process.env.GITHUB_ACTION === "true") log.info("Running in GitHub action");
|
|
67548
67740
|
config.argv(argvOptions);
|
|
67549
|
-
if (configFilePath)
|
|
67550
|
-
|
|
67551
|
-
|
|
67552
|
-
|
|
67741
|
+
if (configFilePath) {
|
|
67742
|
+
if (fs$3.existsSync(configFilePath)) {
|
|
67743
|
+
log.info(`Config file found: ${configFilePath}`);
|
|
67744
|
+
config.file(configFilePath);
|
|
67745
|
+
} else log.debug(`Config file not found: ${configFilePath}`);
|
|
67746
|
+
}
|
|
67553
67747
|
config.env({
|
|
67554
67748
|
lowerCase: true,
|
|
67555
67749
|
parseValues: true,
|
|
@@ -68349,27 +68543,29 @@ var Color = class Color {
|
|
|
68349
68543
|
} else if (a instanceof Object) {
|
|
68350
68544
|
const values = getParameters(a, b);
|
|
68351
68545
|
Object.assign(this, values);
|
|
68352
|
-
} else if (typeof a === "string")
|
|
68353
|
-
|
|
68354
|
-
|
|
68355
|
-
|
|
68356
|
-
|
|
68357
|
-
|
|
68358
|
-
|
|
68359
|
-
|
|
68360
|
-
|
|
68361
|
-
|
|
68362
|
-
|
|
68363
|
-
|
|
68364
|
-
|
|
68365
|
-
|
|
68366
|
-
|
|
68367
|
-
|
|
68368
|
-
|
|
68369
|
-
|
|
68370
|
-
|
|
68371
|
-
|
|
68372
|
-
|
|
68546
|
+
} else if (typeof a === "string") {
|
|
68547
|
+
if (isRgb.test(a)) {
|
|
68548
|
+
const noWhitespace = a.replace(whitespace, "");
|
|
68549
|
+
const [_a, _b, _c] = rgb.exec(noWhitespace).slice(1, 4).map((v) => parseInt(v));
|
|
68550
|
+
Object.assign(this, {
|
|
68551
|
+
_a,
|
|
68552
|
+
_b,
|
|
68553
|
+
_c,
|
|
68554
|
+
_d: 0,
|
|
68555
|
+
space: "rgb"
|
|
68556
|
+
});
|
|
68557
|
+
} else if (isHex.test(a)) {
|
|
68558
|
+
const hexParse = (v) => parseInt(v, 16);
|
|
68559
|
+
const [, _a, _b, _c] = hex.exec(sixDigitHex(a)).map(hexParse);
|
|
68560
|
+
Object.assign(this, {
|
|
68561
|
+
_a,
|
|
68562
|
+
_b,
|
|
68563
|
+
_c,
|
|
68564
|
+
_d: 0,
|
|
68565
|
+
space: "rgb"
|
|
68566
|
+
});
|
|
68567
|
+
} else throw Error("Unsupported string format, can't construct Color");
|
|
68568
|
+
}
|
|
68373
68569
|
const { _a, _b, _c, _d } = this;
|
|
68374
68570
|
const components = this.space === "rgb" ? {
|
|
68375
68571
|
r: _a,
|
|
@@ -70319,13 +70515,15 @@ const easing = {
|
|
|
70319
70515
|
},
|
|
70320
70516
|
bezier: function(x1, y1, x2, y2) {
|
|
70321
70517
|
return function(t) {
|
|
70322
|
-
if (t < 0)
|
|
70323
|
-
|
|
70324
|
-
|
|
70325
|
-
|
|
70326
|
-
else if (
|
|
70327
|
-
|
|
70328
|
-
|
|
70518
|
+
if (t < 0) {
|
|
70519
|
+
if (x1 > 0) return y1 / x1 * t;
|
|
70520
|
+
else if (x2 > 0) return y2 / x2 * t;
|
|
70521
|
+
else return 0;
|
|
70522
|
+
} else if (t > 1) {
|
|
70523
|
+
if (x2 < 1) return (1 - y2) / (1 - x2) * t + (y2 - x2) / (1 - x2);
|
|
70524
|
+
else if (x1 < 1) return (1 - y1) / (1 - x1) * t + (y1 - x1) / (1 - x1);
|
|
70525
|
+
else return 1;
|
|
70526
|
+
} else return 3 * t * (1 - t) ** 2 * y1 + 3 * t ** 2 * (1 - t) * y2 + t ** 3;
|
|
70329
70527
|
};
|
|
70330
70528
|
},
|
|
70331
70529
|
steps: function(steps, stepPosition = "end") {
|
|
@@ -70788,11 +70986,12 @@ var PathArray = class extends SVGArray {
|
|
|
70788
70986
|
const getClassForType = (value) => {
|
|
70789
70987
|
const type = typeof value;
|
|
70790
70988
|
if (type === "number") return SVGNumber;
|
|
70791
|
-
else if (type === "string")
|
|
70792
|
-
|
|
70793
|
-
|
|
70794
|
-
|
|
70795
|
-
|
|
70989
|
+
else if (type === "string") {
|
|
70990
|
+
if (Color.isColor(value)) return Color;
|
|
70991
|
+
else if (delimiter$1.test(value)) return isPathLetter$1.test(value) ? PathArray : SVGArray;
|
|
70992
|
+
else if (numberAndUnit.test(value)) return SVGNumber;
|
|
70993
|
+
else return NonMorphable;
|
|
70994
|
+
} else if (morphableTypes.indexOf(value.constructor) > -1) return value.constructor;
|
|
70796
70995
|
else if (Array.isArray(value)) return SVGArray;
|
|
70797
70996
|
else if (type === "object") return ObjectBag;
|
|
70798
70997
|
else return NonMorphable;
|
|
@@ -72699,12 +72898,12 @@ const fontFamilyMappings = {
|
|
|
72699
72898
|
//#endregion
|
|
72700
72899
|
//#region node_modules/svgdom/src/utils/objectCreationUtils.js
|
|
72701
72900
|
const extend = (...modules) => {
|
|
72702
|
-
var methods = modules.pop(), key, i;
|
|
72703
|
-
for (
|
|
72901
|
+
var methods = modules.pop(), key, i = modules.length - 1;
|
|
72902
|
+
for (; i >= 0; i--) for (key in methods) modules[i].prototype[key] = methods[key];
|
|
72704
72903
|
};
|
|
72705
72904
|
const extendStatic = (...modules) => {
|
|
72706
|
-
var methods = modules.pop(), key, i;
|
|
72707
|
-
for (
|
|
72905
|
+
var methods = modules.pop(), key, i = modules.length - 1;
|
|
72906
|
+
for (; i >= 0; i--) for (key in methods) modules[i][key] = methods[key];
|
|
72708
72907
|
};
|
|
72709
72908
|
const mixin = (mixin, _class) => {
|
|
72710
72909
|
const descriptors = Object.getOwnPropertyDescriptors(mixin);
|
|
@@ -74176,13 +74375,15 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
74176
74375
|
var qn = qname(parser.attribName, true);
|
|
74177
74376
|
var prefix = qn.prefix;
|
|
74178
74377
|
var local = qn.local;
|
|
74179
|
-
if (prefix === "xmlns")
|
|
74180
|
-
|
|
74181
|
-
|
|
74182
|
-
|
|
74183
|
-
|
|
74184
|
-
|
|
74185
|
-
|
|
74378
|
+
if (prefix === "xmlns") {
|
|
74379
|
+
if (local === "xml" && parser.attribValue !== XML_NAMESPACE) strictFail(parser, "xml: prefix must be bound to " + XML_NAMESPACE + "\nActual: " + parser.attribValue);
|
|
74380
|
+
else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) strictFail(parser, "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\nActual: " + parser.attribValue);
|
|
74381
|
+
else {
|
|
74382
|
+
var tag = parser.tag;
|
|
74383
|
+
var parent = parser.tags[parser.tags.length - 1] || parser;
|
|
74384
|
+
if (tag.ns === parent.ns) tag.ns = Object.create(parent.ns);
|
|
74385
|
+
tag.ns[local] = parser.attribValue;
|
|
74386
|
+
}
|
|
74186
74387
|
}
|
|
74187
74388
|
parser.attribList.push([parser.attribName, parser.attribValue]);
|
|
74188
74389
|
} else {
|
|
@@ -74308,14 +74509,16 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
74308
74509
|
if (parser.ENTITIES[entity]) return parser.ENTITIES[entity];
|
|
74309
74510
|
if (parser.ENTITIES[entityLC]) return parser.ENTITIES[entityLC];
|
|
74310
74511
|
entity = entityLC;
|
|
74311
|
-
if (entity.charAt(0) === "#")
|
|
74312
|
-
|
|
74313
|
-
|
|
74314
|
-
|
|
74315
|
-
|
|
74316
|
-
|
|
74317
|
-
|
|
74318
|
-
|
|
74512
|
+
if (entity.charAt(0) === "#") {
|
|
74513
|
+
if (entity.charAt(1) === "x") {
|
|
74514
|
+
entity = entity.slice(2);
|
|
74515
|
+
num = parseInt(entity, 16);
|
|
74516
|
+
numStr = num.toString(16);
|
|
74517
|
+
} else {
|
|
74518
|
+
entity = entity.slice(1);
|
|
74519
|
+
num = parseInt(entity, 10);
|
|
74520
|
+
numStr = num.toString(10);
|
|
74521
|
+
}
|
|
74319
74522
|
}
|
|
74320
74523
|
entity = entity.replace(/^0+/, "");
|
|
74321
74524
|
if (isNaN(num) || numStr.toLowerCase() !== entity || num < 0 || num > 1114111) {
|
|
@@ -74690,13 +74893,15 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
74690
74893
|
else parser.state = S.ATTRIB;
|
|
74691
74894
|
continue;
|
|
74692
74895
|
case S.CLOSE_TAG:
|
|
74693
|
-
if (!parser.tagName)
|
|
74694
|
-
|
|
74695
|
-
|
|
74696
|
-
|
|
74697
|
-
|
|
74698
|
-
|
|
74699
|
-
|
|
74896
|
+
if (!parser.tagName) {
|
|
74897
|
+
if (isWhitespace(c)) continue;
|
|
74898
|
+
else if (notMatch(nameStart, c)) {
|
|
74899
|
+
if (parser.script) {
|
|
74900
|
+
parser.script += "</" + c;
|
|
74901
|
+
parser.state = S.SCRIPT;
|
|
74902
|
+
} else strictFail(parser, "Invalid tagname in closing tag.");
|
|
74903
|
+
} else parser.tagName = c;
|
|
74904
|
+
} else if (c === ">") closeTag(parser);
|
|
74700
74905
|
else if (isMatch(nameBody, c)) parser.tagName += c;
|
|
74701
74906
|
else if (parser.script) {
|
|
74702
74907
|
parser.script += "</" + parser.tagName;
|
|
@@ -75286,21 +75491,21 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
75286
75491
|
const toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + ("0" + i.toString(16)).slice(-2), "");
|
|
75287
75492
|
exports.toHexString = toHexString;
|
|
75288
75493
|
const readInt16LE = (input, offset = 0) => {
|
|
75289
|
-
const val = input[offset] + input[offset + 1] *
|
|
75494
|
+
const val = input[offset] + input[offset + 1] * 256;
|
|
75290
75495
|
return val | (val & 2 ** 15) * 131070;
|
|
75291
75496
|
};
|
|
75292
75497
|
exports.readInt16LE = readInt16LE;
|
|
75293
|
-
const readUInt16BE = (input, offset = 0) => input[offset] *
|
|
75498
|
+
const readUInt16BE = (input, offset = 0) => input[offset] * 256 + input[offset + 1];
|
|
75294
75499
|
exports.readUInt16BE = readUInt16BE;
|
|
75295
|
-
const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75500
|
+
const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256;
|
|
75296
75501
|
exports.readUInt16LE = readUInt16LE;
|
|
75297
|
-
const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75502
|
+
const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256 + input[offset + 2] * 2 ** 16;
|
|
75298
75503
|
exports.readUInt24LE = readUInt24LE;
|
|
75299
|
-
const readInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75504
|
+
const readInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256 + input[offset + 2] * 2 ** 16 + (input[offset + 3] << 24);
|
|
75300
75505
|
exports.readInt32LE = readInt32LE;
|
|
75301
|
-
const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] *
|
|
75506
|
+
const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] * 256 + input[offset + 3];
|
|
75302
75507
|
exports.readUInt32BE = readUInt32BE;
|
|
75303
|
-
const readUInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75508
|
+
const readUInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256 + input[offset + 2] * 2 ** 16 + input[offset + 3] * 2 ** 24;
|
|
75304
75509
|
exports.readUInt32LE = readUInt32LE;
|
|
75305
75510
|
const methods = {
|
|
75306
75511
|
readUInt16BE: exports.readUInt16BE,
|
|
@@ -77182,8 +77387,10 @@ const pointAtLength = function(d, len) {
|
|
|
77182
77387
|
const length = segLengths.reduce((l, c) => l + c, 0);
|
|
77183
77388
|
let i = 0;
|
|
77184
77389
|
let t = len / length;
|
|
77185
|
-
if (t >= 1)
|
|
77186
|
-
|
|
77390
|
+
if (t >= 1) {
|
|
77391
|
+
if (segs[segs.length - 1].p2) return segs[segs.length - 1].p2.native();
|
|
77392
|
+
else return segs[segs.length - 1].p1.native();
|
|
77393
|
+
}
|
|
77187
77394
|
if (t <= 0) return segs[0].p1.native();
|
|
77188
77395
|
while (segs[segs.length - 1] instanceof Move) segs.pop();
|
|
77189
77396
|
let segEnd = 0;
|
|
@@ -77821,8 +78028,10 @@ var Struct = class extends Base {
|
|
|
77821
78028
|
const type = fields[key];
|
|
77822
78029
|
if (typeof type === "function") val = type.call(res, res);
|
|
77823
78030
|
else val = type.decode(stream, res);
|
|
77824
|
-
if (val !== void 0)
|
|
77825
|
-
|
|
78031
|
+
if (val !== void 0) {
|
|
78032
|
+
if (val instanceof PropertyDescriptor) Object.defineProperty(res, key, val);
|
|
78033
|
+
else res[key] = val;
|
|
78034
|
+
}
|
|
77826
78035
|
res._currentOffset = stream.pos - res._startOffset;
|
|
77827
78036
|
}
|
|
77828
78037
|
}
|
|
@@ -78142,8 +78351,8 @@ var require_base64_js = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
78142
78351
|
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
|
|
78143
78352
|
var curByte = 0;
|
|
78144
78353
|
var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
|
|
78145
|
-
var i;
|
|
78146
|
-
for (
|
|
78354
|
+
var i = 0;
|
|
78355
|
+
for (; i < len; i += 4) {
|
|
78147
78356
|
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
|
|
78148
78357
|
arr[curByte++] = tmp >> 16 & 255;
|
|
78149
78358
|
arr[curByte++] = tmp >> 8 & 255;
|
|
@@ -78210,8 +78419,8 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78210
78419
|
var code_tree = new Tree();
|
|
78211
78420
|
var lengths = /* @__PURE__ */ new Uint8Array(320);
|
|
78212
78421
|
function tinf_build_bits_base(bits, base, delta, first) {
|
|
78213
|
-
var i, sum;
|
|
78214
|
-
for (
|
|
78422
|
+
var i = 0, sum;
|
|
78423
|
+
for (; i < delta; ++i) bits[i] = 0;
|
|
78215
78424
|
for (i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta | 0;
|
|
78216
78425
|
for (sum = first, i = 0; i < 30; ++i) {
|
|
78217
78426
|
base[i] = sum;
|
|
@@ -78219,8 +78428,8 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78219
78428
|
}
|
|
78220
78429
|
}
|
|
78221
78430
|
function tinf_build_fixed_trees(lt, dt) {
|
|
78222
|
-
var i;
|
|
78223
|
-
for (
|
|
78431
|
+
var i = 0;
|
|
78432
|
+
for (; i < 7; ++i) lt.table[i] = 0;
|
|
78224
78433
|
lt.table[7] = 24;
|
|
78225
78434
|
lt.table[8] = 152;
|
|
78226
78435
|
lt.table[9] = 112;
|
|
@@ -78234,8 +78443,8 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78234
78443
|
}
|
|
78235
78444
|
var offs = /* @__PURE__ */ new Uint16Array(16);
|
|
78236
78445
|
function tinf_build_tree(t, lengths, off, num) {
|
|
78237
|
-
var i, sum;
|
|
78238
|
-
for (
|
|
78446
|
+
var i = 0, sum;
|
|
78447
|
+
for (; i < 16; ++i) t.table[i] = 0;
|
|
78239
78448
|
for (i = 0; i < num; ++i) t.table[lengths[off + i]]++;
|
|
78240
78449
|
t.table[0] = 0;
|
|
78241
78450
|
for (sum = 0, i = 0; i < 16; ++i) {
|
|
@@ -78367,8 +78576,10 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78367
78576
|
}
|
|
78368
78577
|
if (res !== TINF_OK) throw new Error("Data error");
|
|
78369
78578
|
} while (!bfinal);
|
|
78370
|
-
if (d.destLen < d.dest.length)
|
|
78371
|
-
|
|
78579
|
+
if (d.destLen < d.dest.length) {
|
|
78580
|
+
if (typeof d.dest.slice === "function") return d.dest.slice(0, d.destLen);
|
|
78581
|
+
else return d.dest.subarray(0, d.destLen);
|
|
78582
|
+
}
|
|
78372
78583
|
return d.dest;
|
|
78373
78584
|
}
|
|
78374
78585
|
tinf_build_fixed_trees(sltree, sdtree);
|
|
@@ -204230,8 +204441,8 @@ var require_decode = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
204230
204441
|
}
|
|
204231
204442
|
function InverseMoveToFrontTransform(v, v_len) {
|
|
204232
204443
|
var mtf = /* @__PURE__ */ new Uint8Array(256);
|
|
204233
|
-
var i;
|
|
204234
|
-
for (
|
|
204444
|
+
var i = 0;
|
|
204445
|
+
for (; i < 256; ++i) mtf[i] = i;
|
|
204235
204446
|
for (i = 0; i < v_len; ++i) {
|
|
204236
204447
|
var index = v[i];
|
|
204237
204448
|
v[i] = mtf[index];
|
|
@@ -204607,25 +204818,26 @@ var require_decode = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
204607
204818
|
if (pos < max_backward_distance && max_distance !== max_backward_distance) max_distance = pos;
|
|
204608
204819
|
else max_distance = max_backward_distance;
|
|
204609
204820
|
copy_dst = pos & ringbuffer_mask;
|
|
204610
|
-
if (distance > max_distance)
|
|
204611
|
-
|
|
204612
|
-
|
|
204613
|
-
|
|
204614
|
-
|
|
204615
|
-
|
|
204616
|
-
|
|
204617
|
-
|
|
204618
|
-
|
|
204619
|
-
|
|
204620
|
-
|
|
204621
|
-
|
|
204622
|
-
|
|
204623
|
-
|
|
204624
|
-
|
|
204625
|
-
|
|
204821
|
+
if (distance > max_distance) {
|
|
204822
|
+
if (copy_length >= BrotliDictionary.minDictionaryWordLength && copy_length <= BrotliDictionary.maxDictionaryWordLength) {
|
|
204823
|
+
var offset = BrotliDictionary.offsetsByLength[copy_length];
|
|
204824
|
+
var word_id = distance - max_distance - 1;
|
|
204825
|
+
var shift = BrotliDictionary.sizeBitsByLength[copy_length];
|
|
204826
|
+
var word_idx = word_id & (1 << shift) - 1;
|
|
204827
|
+
var transform_idx = word_id >> shift;
|
|
204828
|
+
offset += word_idx * copy_length;
|
|
204829
|
+
if (transform_idx < Transform.kNumTransforms) {
|
|
204830
|
+
var len = Transform.transformDictionaryWord(ringbuffer, copy_dst, offset, copy_length, transform_idx);
|
|
204831
|
+
copy_dst += len;
|
|
204832
|
+
pos += len;
|
|
204833
|
+
meta_block_remaining_len -= len;
|
|
204834
|
+
if (copy_dst >= ringbuffer_end) {
|
|
204835
|
+
output.write(ringbuffer, ringbuffer_size);
|
|
204836
|
+
for (var _x = 0; _x < copy_dst - ringbuffer_end; _x++) ringbuffer[_x] = ringbuffer[ringbuffer_end + _x];
|
|
204837
|
+
}
|
|
204838
|
+
} else throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + " len: " + copy_length + " bytes left: " + meta_block_remaining_len);
|
|
204626
204839
|
} else throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + " len: " + copy_length + " bytes left: " + meta_block_remaining_len);
|
|
204627
|
-
} else
|
|
204628
|
-
else {
|
|
204840
|
+
} else {
|
|
204629
204841
|
if (distance_code > 0) {
|
|
204630
204842
|
dist_rb[dist_rb_idx & 3] = distance;
|
|
204631
204843
|
++dist_rb_idx;
|
|
@@ -205822,8 +206034,10 @@ var $61aa549f16d58b9b$export$2e2bcd8739ae039 = class {
|
|
|
205822
206034
|
let field = this.fields[b];
|
|
205823
206035
|
if (!field) throw new Error(`Unknown operator ${b}`);
|
|
205824
206036
|
let val = this.decodeOperands(field[2], stream, ret, operands);
|
|
205825
|
-
if (val != null)
|
|
205826
|
-
|
|
206037
|
+
if (val != null) {
|
|
206038
|
+
if (val instanceof PropertyDescriptor) Object.defineProperty(ret, field[1], val);
|
|
206039
|
+
else ret[field[1]] = val;
|
|
206040
|
+
}
|
|
205827
206041
|
operands = [];
|
|
205828
206042
|
} else operands.push($c2d28e92708f99da$export$2e2bcd8739ae039.decode(stream, b));
|
|
205829
206043
|
}
|
|
@@ -213224,7 +213438,6 @@ var $f43aec954cdfdf21$export$2e2bcd8739ae039 = class $f43aec954cdfdf21$export$2e
|
|
|
213224
213438
|
}
|
|
213225
213439
|
cx = p3x;
|
|
213226
213440
|
cy = p3y;
|
|
213227
|
-
break;
|
|
213228
213441
|
}
|
|
213229
213442
|
return this._bbox = Object.freeze(bbox);
|
|
213230
213443
|
}
|
|
@@ -215347,9 +215560,11 @@ var $4c1709dee528ea76$export$2e2bcd8739ae039 = class $4c1709dee528ea76$export$2e
|
|
|
215347
215560
|
* @param {number[]} characters
|
|
215348
215561
|
* @return {Glyph}
|
|
215349
215562
|
*/ getGlyph(glyph, characters = []) {
|
|
215350
|
-
if (!this._glyphs[glyph])
|
|
215351
|
-
|
|
215352
|
-
|
|
215563
|
+
if (!this._glyphs[glyph]) {
|
|
215564
|
+
if (this.directory.tables.sbix) this._glyphs[glyph] = new $25d8f049c222084c$export$2e2bcd8739ae039(glyph, characters, this);
|
|
215565
|
+
else if (this.directory.tables.COLR && this.directory.tables.CPAL) this._glyphs[glyph] = new $0d411f0165859681$export$2e2bcd8739ae039(glyph, characters, this);
|
|
215566
|
+
else this._getBaseGlyph(glyph, characters);
|
|
215567
|
+
}
|
|
215353
215568
|
return this._glyphs[glyph] || null;
|
|
215354
215569
|
}
|
|
215355
215570
|
/**
|
|
@@ -215661,10 +215876,12 @@ var $21ee218f84ac7f32$export$2e2bcd8739ae039 = class extends $4c1709dee528ea76$e
|
|
|
215661
215876
|
return super._decodeTable(table);
|
|
215662
215877
|
}
|
|
215663
215878
|
_getBaseGlyph(glyph, characters = []) {
|
|
215664
|
-
if (!this._glyphs[glyph])
|
|
215665
|
-
if (
|
|
215666
|
-
|
|
215667
|
-
|
|
215879
|
+
if (!this._glyphs[glyph]) {
|
|
215880
|
+
if (this.directory.tables.glyf && this.directory.tables.glyf.transformed) {
|
|
215881
|
+
if (!this._transformedGlyphs) this._transformGlyfTable();
|
|
215882
|
+
return this._glyphs[glyph] = new $8046190c9f1ad19e$export$2e2bcd8739ae039(glyph, characters, this);
|
|
215883
|
+
} else return super._getBaseGlyph(glyph, characters);
|
|
215884
|
+
}
|
|
215668
215885
|
}
|
|
215669
215886
|
_transformGlyfTable() {
|
|
215670
215887
|
this._decompress();
|
|
@@ -217124,6 +217341,13 @@ function updateTitle(sectionToken, inputs) {
|
|
|
217124
217341
|
}
|
|
217125
217342
|
//#endregion
|
|
217126
217343
|
//#region src/sections/update-usage.ts
|
|
217344
|
+
/**
|
|
217345
|
+
* Renders the `usage` section: a fenced workflow snippet naming every action input,
|
|
217346
|
+
* each preceded by its description and default as YAML comments.
|
|
217347
|
+
* @param {ReadmeSection} sectionToken - The README marker pair to write the section into.
|
|
217348
|
+
* @param {Inputs} inputs - The parsed action metadata and the README editor to write with.
|
|
217349
|
+
* @returns {Promise<Record<string, string>>} The rendered section, keyed by its section token.
|
|
217350
|
+
*/
|
|
217127
217351
|
async function updateUsage(sectionToken, inputs) {
|
|
217128
217352
|
const log = new LogTask(sectionToken);
|
|
217129
217353
|
log.start();
|
|
@@ -217133,6 +217357,8 @@ async function updateUsage(sectionToken, inputs) {
|
|
|
217133
217357
|
log.info(`Version string: ${versionString}`);
|
|
217134
217358
|
const actionReference = `${actionName}@${versionString}`;
|
|
217135
217359
|
const indent = " # ";
|
|
217360
|
+
const defaultLabel = "Default: ";
|
|
217361
|
+
const defaultHang = " ".repeat(9);
|
|
217136
217362
|
const content = [];
|
|
217137
217363
|
content.push("```yaml", `- uses: ${actionReference}`, " with:");
|
|
217138
217364
|
const inp = inputs.action.inputs;
|
|
@@ -217159,7 +217385,11 @@ async function updateUsage(sectionToken, inputs) {
|
|
|
217159
217385
|
if (input !== void 0) {
|
|
217160
217386
|
if (!firstInput) content.push("");
|
|
217161
217387
|
content.push(...descriptions[key]);
|
|
217162
|
-
if (input.default !== void 0)
|
|
217388
|
+
if (input.default !== void 0) {
|
|
217389
|
+
const [firstLine, ...rest] = `${input.default}`.split(/\r\n|\n|\r/);
|
|
217390
|
+
content.push(`${indent}${defaultLabel}${firstLine}`.trimEnd());
|
|
217391
|
+
for (const line of rest) content.push(`${indent}${defaultHang}${line}`.trimEnd());
|
|
217392
|
+
}
|
|
217163
217393
|
content.push(` ${key}: ''`);
|
|
217164
217394
|
firstInput = false;
|
|
217165
217395
|
}
|