github-action-readme-generator 1.12.8 → 1.12.9
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 +7 -0
- package/README.md +1 -1
- package/dist/bin/index.js +668 -519
- package/dist/mjs/index.d.ts +2 -3
- package/dist/mjs/index.js +28 -12
- package/package.json +4 -4
package/dist/bin/index.js
CHANGED
|
@@ -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,
|
|
@@ -67546,10 +67657,12 @@ function loadConfig(log, providedConfig, configFilePath) {
|
|
|
67546
67657
|
const config = providedConfig ?? new import_nconf.Provider();
|
|
67547
67658
|
if (process.env.GITHUB_ACTION === "true") log.info("Running in GitHub action");
|
|
67548
67659
|
config.argv(argvOptions);
|
|
67549
|
-
if (configFilePath)
|
|
67550
|
-
|
|
67551
|
-
|
|
67552
|
-
|
|
67660
|
+
if (configFilePath) {
|
|
67661
|
+
if (fs$3.existsSync(configFilePath)) {
|
|
67662
|
+
log.info(`Config file found: ${configFilePath}`);
|
|
67663
|
+
config.file(configFilePath);
|
|
67664
|
+
} else log.debug(`Config file not found: ${configFilePath}`);
|
|
67665
|
+
}
|
|
67553
67666
|
config.env({
|
|
67554
67667
|
lowerCase: true,
|
|
67555
67668
|
parseValues: true,
|
|
@@ -68349,27 +68462,29 @@ var Color = class Color {
|
|
|
68349
68462
|
} else if (a instanceof Object) {
|
|
68350
68463
|
const values = getParameters(a, b);
|
|
68351
68464
|
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
|
-
|
|
68465
|
+
} else if (typeof a === "string") {
|
|
68466
|
+
if (isRgb.test(a)) {
|
|
68467
|
+
const noWhitespace = a.replace(whitespace, "");
|
|
68468
|
+
const [_a, _b, _c] = rgb.exec(noWhitespace).slice(1, 4).map((v) => parseInt(v));
|
|
68469
|
+
Object.assign(this, {
|
|
68470
|
+
_a,
|
|
68471
|
+
_b,
|
|
68472
|
+
_c,
|
|
68473
|
+
_d: 0,
|
|
68474
|
+
space: "rgb"
|
|
68475
|
+
});
|
|
68476
|
+
} else if (isHex.test(a)) {
|
|
68477
|
+
const hexParse = (v) => parseInt(v, 16);
|
|
68478
|
+
const [, _a, _b, _c] = hex.exec(sixDigitHex(a)).map(hexParse);
|
|
68479
|
+
Object.assign(this, {
|
|
68480
|
+
_a,
|
|
68481
|
+
_b,
|
|
68482
|
+
_c,
|
|
68483
|
+
_d: 0,
|
|
68484
|
+
space: "rgb"
|
|
68485
|
+
});
|
|
68486
|
+
} else throw Error("Unsupported string format, can't construct Color");
|
|
68487
|
+
}
|
|
68373
68488
|
const { _a, _b, _c, _d } = this;
|
|
68374
68489
|
const components = this.space === "rgb" ? {
|
|
68375
68490
|
r: _a,
|
|
@@ -70319,13 +70434,15 @@ const easing = {
|
|
|
70319
70434
|
},
|
|
70320
70435
|
bezier: function(x1, y1, x2, y2) {
|
|
70321
70436
|
return function(t) {
|
|
70322
|
-
if (t < 0)
|
|
70323
|
-
|
|
70324
|
-
|
|
70325
|
-
|
|
70326
|
-
else if (
|
|
70327
|
-
|
|
70328
|
-
|
|
70437
|
+
if (t < 0) {
|
|
70438
|
+
if (x1 > 0) return y1 / x1 * t;
|
|
70439
|
+
else if (x2 > 0) return y2 / x2 * t;
|
|
70440
|
+
else return 0;
|
|
70441
|
+
} else if (t > 1) {
|
|
70442
|
+
if (x2 < 1) return (1 - y2) / (1 - x2) * t + (y2 - x2) / (1 - x2);
|
|
70443
|
+
else if (x1 < 1) return (1 - y1) / (1 - x1) * t + (y1 - x1) / (1 - x1);
|
|
70444
|
+
else return 1;
|
|
70445
|
+
} else return 3 * t * (1 - t) ** 2 * y1 + 3 * t ** 2 * (1 - t) * y2 + t ** 3;
|
|
70329
70446
|
};
|
|
70330
70447
|
},
|
|
70331
70448
|
steps: function(steps, stepPosition = "end") {
|
|
@@ -70788,11 +70905,12 @@ var PathArray = class extends SVGArray {
|
|
|
70788
70905
|
const getClassForType = (value) => {
|
|
70789
70906
|
const type = typeof value;
|
|
70790
70907
|
if (type === "number") return SVGNumber;
|
|
70791
|
-
else if (type === "string")
|
|
70792
|
-
|
|
70793
|
-
|
|
70794
|
-
|
|
70795
|
-
|
|
70908
|
+
else if (type === "string") {
|
|
70909
|
+
if (Color.isColor(value)) return Color;
|
|
70910
|
+
else if (delimiter$1.test(value)) return isPathLetter$1.test(value) ? PathArray : SVGArray;
|
|
70911
|
+
else if (numberAndUnit.test(value)) return SVGNumber;
|
|
70912
|
+
else return NonMorphable;
|
|
70913
|
+
} else if (morphableTypes.indexOf(value.constructor) > -1) return value.constructor;
|
|
70796
70914
|
else if (Array.isArray(value)) return SVGArray;
|
|
70797
70915
|
else if (type === "object") return ObjectBag;
|
|
70798
70916
|
else return NonMorphable;
|
|
@@ -72699,12 +72817,12 @@ const fontFamilyMappings = {
|
|
|
72699
72817
|
//#endregion
|
|
72700
72818
|
//#region node_modules/svgdom/src/utils/objectCreationUtils.js
|
|
72701
72819
|
const extend = (...modules) => {
|
|
72702
|
-
var methods = modules.pop(), key, i;
|
|
72703
|
-
for (
|
|
72820
|
+
var methods = modules.pop(), key, i = modules.length - 1;
|
|
72821
|
+
for (; i >= 0; i--) for (key in methods) modules[i].prototype[key] = methods[key];
|
|
72704
72822
|
};
|
|
72705
72823
|
const extendStatic = (...modules) => {
|
|
72706
|
-
var methods = modules.pop(), key, i;
|
|
72707
|
-
for (
|
|
72824
|
+
var methods = modules.pop(), key, i = modules.length - 1;
|
|
72825
|
+
for (; i >= 0; i--) for (key in methods) modules[i][key] = methods[key];
|
|
72708
72826
|
};
|
|
72709
72827
|
const mixin = (mixin, _class) => {
|
|
72710
72828
|
const descriptors = Object.getOwnPropertyDescriptors(mixin);
|
|
@@ -74176,13 +74294,15 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
74176
74294
|
var qn = qname(parser.attribName, true);
|
|
74177
74295
|
var prefix = qn.prefix;
|
|
74178
74296
|
var local = qn.local;
|
|
74179
|
-
if (prefix === "xmlns")
|
|
74180
|
-
|
|
74181
|
-
|
|
74182
|
-
|
|
74183
|
-
|
|
74184
|
-
|
|
74185
|
-
|
|
74297
|
+
if (prefix === "xmlns") {
|
|
74298
|
+
if (local === "xml" && parser.attribValue !== XML_NAMESPACE) strictFail(parser, "xml: prefix must be bound to " + XML_NAMESPACE + "\nActual: " + parser.attribValue);
|
|
74299
|
+
else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) strictFail(parser, "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\nActual: " + parser.attribValue);
|
|
74300
|
+
else {
|
|
74301
|
+
var tag = parser.tag;
|
|
74302
|
+
var parent = parser.tags[parser.tags.length - 1] || parser;
|
|
74303
|
+
if (tag.ns === parent.ns) tag.ns = Object.create(parent.ns);
|
|
74304
|
+
tag.ns[local] = parser.attribValue;
|
|
74305
|
+
}
|
|
74186
74306
|
}
|
|
74187
74307
|
parser.attribList.push([parser.attribName, parser.attribValue]);
|
|
74188
74308
|
} else {
|
|
@@ -74308,14 +74428,16 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
74308
74428
|
if (parser.ENTITIES[entity]) return parser.ENTITIES[entity];
|
|
74309
74429
|
if (parser.ENTITIES[entityLC]) return parser.ENTITIES[entityLC];
|
|
74310
74430
|
entity = entityLC;
|
|
74311
|
-
if (entity.charAt(0) === "#")
|
|
74312
|
-
|
|
74313
|
-
|
|
74314
|
-
|
|
74315
|
-
|
|
74316
|
-
|
|
74317
|
-
|
|
74318
|
-
|
|
74431
|
+
if (entity.charAt(0) === "#") {
|
|
74432
|
+
if (entity.charAt(1) === "x") {
|
|
74433
|
+
entity = entity.slice(2);
|
|
74434
|
+
num = parseInt(entity, 16);
|
|
74435
|
+
numStr = num.toString(16);
|
|
74436
|
+
} else {
|
|
74437
|
+
entity = entity.slice(1);
|
|
74438
|
+
num = parseInt(entity, 10);
|
|
74439
|
+
numStr = num.toString(10);
|
|
74440
|
+
}
|
|
74319
74441
|
}
|
|
74320
74442
|
entity = entity.replace(/^0+/, "");
|
|
74321
74443
|
if (isNaN(num) || numStr.toLowerCase() !== entity || num < 0 || num > 1114111) {
|
|
@@ -74690,13 +74812,15 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
74690
74812
|
else parser.state = S.ATTRIB;
|
|
74691
74813
|
continue;
|
|
74692
74814
|
case S.CLOSE_TAG:
|
|
74693
|
-
if (!parser.tagName)
|
|
74694
|
-
|
|
74695
|
-
|
|
74696
|
-
|
|
74697
|
-
|
|
74698
|
-
|
|
74699
|
-
|
|
74815
|
+
if (!parser.tagName) {
|
|
74816
|
+
if (isWhitespace(c)) continue;
|
|
74817
|
+
else if (notMatch(nameStart, c)) {
|
|
74818
|
+
if (parser.script) {
|
|
74819
|
+
parser.script += "</" + c;
|
|
74820
|
+
parser.state = S.SCRIPT;
|
|
74821
|
+
} else strictFail(parser, "Invalid tagname in closing tag.");
|
|
74822
|
+
} else parser.tagName = c;
|
|
74823
|
+
} else if (c === ">") closeTag(parser);
|
|
74700
74824
|
else if (isMatch(nameBody, c)) parser.tagName += c;
|
|
74701
74825
|
else if (parser.script) {
|
|
74702
74826
|
parser.script += "</" + parser.tagName;
|
|
@@ -75286,21 +75410,21 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
75286
75410
|
const toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + ("0" + i.toString(16)).slice(-2), "");
|
|
75287
75411
|
exports.toHexString = toHexString;
|
|
75288
75412
|
const readInt16LE = (input, offset = 0) => {
|
|
75289
|
-
const val = input[offset] + input[offset + 1] *
|
|
75413
|
+
const val = input[offset] + input[offset + 1] * 256;
|
|
75290
75414
|
return val | (val & 2 ** 15) * 131070;
|
|
75291
75415
|
};
|
|
75292
75416
|
exports.readInt16LE = readInt16LE;
|
|
75293
|
-
const readUInt16BE = (input, offset = 0) => input[offset] *
|
|
75417
|
+
const readUInt16BE = (input, offset = 0) => input[offset] * 256 + input[offset + 1];
|
|
75294
75418
|
exports.readUInt16BE = readUInt16BE;
|
|
75295
|
-
const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75419
|
+
const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256;
|
|
75296
75420
|
exports.readUInt16LE = readUInt16LE;
|
|
75297
|
-
const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75421
|
+
const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256 + input[offset + 2] * 2 ** 16;
|
|
75298
75422
|
exports.readUInt24LE = readUInt24LE;
|
|
75299
|
-
const readInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75423
|
+
const readInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256 + input[offset + 2] * 2 ** 16 + (input[offset + 3] << 24);
|
|
75300
75424
|
exports.readInt32LE = readInt32LE;
|
|
75301
|
-
const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] *
|
|
75425
|
+
const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] * 256 + input[offset + 3];
|
|
75302
75426
|
exports.readUInt32BE = readUInt32BE;
|
|
75303
|
-
const readUInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] *
|
|
75427
|
+
const readUInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 256 + input[offset + 2] * 2 ** 16 + input[offset + 3] * 2 ** 24;
|
|
75304
75428
|
exports.readUInt32LE = readUInt32LE;
|
|
75305
75429
|
const methods = {
|
|
75306
75430
|
readUInt16BE: exports.readUInt16BE,
|
|
@@ -77182,8 +77306,10 @@ const pointAtLength = function(d, len) {
|
|
|
77182
77306
|
const length = segLengths.reduce((l, c) => l + c, 0);
|
|
77183
77307
|
let i = 0;
|
|
77184
77308
|
let t = len / length;
|
|
77185
|
-
if (t >= 1)
|
|
77186
|
-
|
|
77309
|
+
if (t >= 1) {
|
|
77310
|
+
if (segs[segs.length - 1].p2) return segs[segs.length - 1].p2.native();
|
|
77311
|
+
else return segs[segs.length - 1].p1.native();
|
|
77312
|
+
}
|
|
77187
77313
|
if (t <= 0) return segs[0].p1.native();
|
|
77188
77314
|
while (segs[segs.length - 1] instanceof Move) segs.pop();
|
|
77189
77315
|
let segEnd = 0;
|
|
@@ -77821,8 +77947,10 @@ var Struct = class extends Base {
|
|
|
77821
77947
|
const type = fields[key];
|
|
77822
77948
|
if (typeof type === "function") val = type.call(res, res);
|
|
77823
77949
|
else val = type.decode(stream, res);
|
|
77824
|
-
if (val !== void 0)
|
|
77825
|
-
|
|
77950
|
+
if (val !== void 0) {
|
|
77951
|
+
if (val instanceof PropertyDescriptor) Object.defineProperty(res, key, val);
|
|
77952
|
+
else res[key] = val;
|
|
77953
|
+
}
|
|
77826
77954
|
res._currentOffset = stream.pos - res._startOffset;
|
|
77827
77955
|
}
|
|
77828
77956
|
}
|
|
@@ -78142,8 +78270,8 @@ var require_base64_js = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
78142
78270
|
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
|
|
78143
78271
|
var curByte = 0;
|
|
78144
78272
|
var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
|
|
78145
|
-
var i;
|
|
78146
|
-
for (
|
|
78273
|
+
var i = 0;
|
|
78274
|
+
for (; i < len; i += 4) {
|
|
78147
78275
|
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
|
|
78148
78276
|
arr[curByte++] = tmp >> 16 & 255;
|
|
78149
78277
|
arr[curByte++] = tmp >> 8 & 255;
|
|
@@ -78210,8 +78338,8 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78210
78338
|
var code_tree = new Tree();
|
|
78211
78339
|
var lengths = /* @__PURE__ */ new Uint8Array(320);
|
|
78212
78340
|
function tinf_build_bits_base(bits, base, delta, first) {
|
|
78213
|
-
var i, sum;
|
|
78214
|
-
for (
|
|
78341
|
+
var i = 0, sum;
|
|
78342
|
+
for (; i < delta; ++i) bits[i] = 0;
|
|
78215
78343
|
for (i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta | 0;
|
|
78216
78344
|
for (sum = first, i = 0; i < 30; ++i) {
|
|
78217
78345
|
base[i] = sum;
|
|
@@ -78219,8 +78347,8 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78219
78347
|
}
|
|
78220
78348
|
}
|
|
78221
78349
|
function tinf_build_fixed_trees(lt, dt) {
|
|
78222
|
-
var i;
|
|
78223
|
-
for (
|
|
78350
|
+
var i = 0;
|
|
78351
|
+
for (; i < 7; ++i) lt.table[i] = 0;
|
|
78224
78352
|
lt.table[7] = 24;
|
|
78225
78353
|
lt.table[8] = 152;
|
|
78226
78354
|
lt.table[9] = 112;
|
|
@@ -78234,8 +78362,8 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78234
78362
|
}
|
|
78235
78363
|
var offs = /* @__PURE__ */ new Uint16Array(16);
|
|
78236
78364
|
function tinf_build_tree(t, lengths, off, num) {
|
|
78237
|
-
var i, sum;
|
|
78238
|
-
for (
|
|
78365
|
+
var i = 0, sum;
|
|
78366
|
+
for (; i < 16; ++i) t.table[i] = 0;
|
|
78239
78367
|
for (i = 0; i < num; ++i) t.table[lengths[off + i]]++;
|
|
78240
78368
|
t.table[0] = 0;
|
|
78241
78369
|
for (sum = 0, i = 0; i < 16; ++i) {
|
|
@@ -78367,8 +78495,10 @@ var require_tiny_inflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
|
|
|
78367
78495
|
}
|
|
78368
78496
|
if (res !== TINF_OK) throw new Error("Data error");
|
|
78369
78497
|
} while (!bfinal);
|
|
78370
|
-
if (d.destLen < d.dest.length)
|
|
78371
|
-
|
|
78498
|
+
if (d.destLen < d.dest.length) {
|
|
78499
|
+
if (typeof d.dest.slice === "function") return d.dest.slice(0, d.destLen);
|
|
78500
|
+
else return d.dest.subarray(0, d.destLen);
|
|
78501
|
+
}
|
|
78372
78502
|
return d.dest;
|
|
78373
78503
|
}
|
|
78374
78504
|
tinf_build_fixed_trees(sltree, sdtree);
|
|
@@ -204230,8 +204360,8 @@ var require_decode = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
204230
204360
|
}
|
|
204231
204361
|
function InverseMoveToFrontTransform(v, v_len) {
|
|
204232
204362
|
var mtf = /* @__PURE__ */ new Uint8Array(256);
|
|
204233
|
-
var i;
|
|
204234
|
-
for (
|
|
204363
|
+
var i = 0;
|
|
204364
|
+
for (; i < 256; ++i) mtf[i] = i;
|
|
204235
204365
|
for (i = 0; i < v_len; ++i) {
|
|
204236
204366
|
var index = v[i];
|
|
204237
204367
|
v[i] = mtf[index];
|
|
@@ -204607,25 +204737,26 @@ var require_decode = /* @__PURE__ */ __commonJSMin(((exports) => {
|
|
|
204607
204737
|
if (pos < max_backward_distance && max_distance !== max_backward_distance) max_distance = pos;
|
|
204608
204738
|
else max_distance = max_backward_distance;
|
|
204609
204739
|
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
|
-
|
|
204740
|
+
if (distance > max_distance) {
|
|
204741
|
+
if (copy_length >= BrotliDictionary.minDictionaryWordLength && copy_length <= BrotliDictionary.maxDictionaryWordLength) {
|
|
204742
|
+
var offset = BrotliDictionary.offsetsByLength[copy_length];
|
|
204743
|
+
var word_id = distance - max_distance - 1;
|
|
204744
|
+
var shift = BrotliDictionary.sizeBitsByLength[copy_length];
|
|
204745
|
+
var word_idx = word_id & (1 << shift) - 1;
|
|
204746
|
+
var transform_idx = word_id >> shift;
|
|
204747
|
+
offset += word_idx * copy_length;
|
|
204748
|
+
if (transform_idx < Transform.kNumTransforms) {
|
|
204749
|
+
var len = Transform.transformDictionaryWord(ringbuffer, copy_dst, offset, copy_length, transform_idx);
|
|
204750
|
+
copy_dst += len;
|
|
204751
|
+
pos += len;
|
|
204752
|
+
meta_block_remaining_len -= len;
|
|
204753
|
+
if (copy_dst >= ringbuffer_end) {
|
|
204754
|
+
output.write(ringbuffer, ringbuffer_size);
|
|
204755
|
+
for (var _x = 0; _x < copy_dst - ringbuffer_end; _x++) ringbuffer[_x] = ringbuffer[ringbuffer_end + _x];
|
|
204756
|
+
}
|
|
204757
|
+
} else throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + " len: " + copy_length + " bytes left: " + meta_block_remaining_len);
|
|
204626
204758
|
} else throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance + " len: " + copy_length + " bytes left: " + meta_block_remaining_len);
|
|
204627
|
-
} else
|
|
204628
|
-
else {
|
|
204759
|
+
} else {
|
|
204629
204760
|
if (distance_code > 0) {
|
|
204630
204761
|
dist_rb[dist_rb_idx & 3] = distance;
|
|
204631
204762
|
++dist_rb_idx;
|
|
@@ -205822,8 +205953,10 @@ var $61aa549f16d58b9b$export$2e2bcd8739ae039 = class {
|
|
|
205822
205953
|
let field = this.fields[b];
|
|
205823
205954
|
if (!field) throw new Error(`Unknown operator ${b}`);
|
|
205824
205955
|
let val = this.decodeOperands(field[2], stream, ret, operands);
|
|
205825
|
-
if (val != null)
|
|
205826
|
-
|
|
205956
|
+
if (val != null) {
|
|
205957
|
+
if (val instanceof PropertyDescriptor) Object.defineProperty(ret, field[1], val);
|
|
205958
|
+
else ret[field[1]] = val;
|
|
205959
|
+
}
|
|
205827
205960
|
operands = [];
|
|
205828
205961
|
} else operands.push($c2d28e92708f99da$export$2e2bcd8739ae039.decode(stream, b));
|
|
205829
205962
|
}
|
|
@@ -213224,7 +213357,6 @@ var $f43aec954cdfdf21$export$2e2bcd8739ae039 = class $f43aec954cdfdf21$export$2e
|
|
|
213224
213357
|
}
|
|
213225
213358
|
cx = p3x;
|
|
213226
213359
|
cy = p3y;
|
|
213227
|
-
break;
|
|
213228
213360
|
}
|
|
213229
213361
|
return this._bbox = Object.freeze(bbox);
|
|
213230
213362
|
}
|
|
@@ -215347,9 +215479,11 @@ var $4c1709dee528ea76$export$2e2bcd8739ae039 = class $4c1709dee528ea76$export$2e
|
|
|
215347
215479
|
* @param {number[]} characters
|
|
215348
215480
|
* @return {Glyph}
|
|
215349
215481
|
*/ getGlyph(glyph, characters = []) {
|
|
215350
|
-
if (!this._glyphs[glyph])
|
|
215351
|
-
|
|
215352
|
-
|
|
215482
|
+
if (!this._glyphs[glyph]) {
|
|
215483
|
+
if (this.directory.tables.sbix) this._glyphs[glyph] = new $25d8f049c222084c$export$2e2bcd8739ae039(glyph, characters, this);
|
|
215484
|
+
else if (this.directory.tables.COLR && this.directory.tables.CPAL) this._glyphs[glyph] = new $0d411f0165859681$export$2e2bcd8739ae039(glyph, characters, this);
|
|
215485
|
+
else this._getBaseGlyph(glyph, characters);
|
|
215486
|
+
}
|
|
215353
215487
|
return this._glyphs[glyph] || null;
|
|
215354
215488
|
}
|
|
215355
215489
|
/**
|
|
@@ -215661,10 +215795,12 @@ var $21ee218f84ac7f32$export$2e2bcd8739ae039 = class extends $4c1709dee528ea76$e
|
|
|
215661
215795
|
return super._decodeTable(table);
|
|
215662
215796
|
}
|
|
215663
215797
|
_getBaseGlyph(glyph, characters = []) {
|
|
215664
|
-
if (!this._glyphs[glyph])
|
|
215665
|
-
if (
|
|
215666
|
-
|
|
215667
|
-
|
|
215798
|
+
if (!this._glyphs[glyph]) {
|
|
215799
|
+
if (this.directory.tables.glyf && this.directory.tables.glyf.transformed) {
|
|
215800
|
+
if (!this._transformedGlyphs) this._transformGlyfTable();
|
|
215801
|
+
return this._glyphs[glyph] = new $8046190c9f1ad19e$export$2e2bcd8739ae039(glyph, characters, this);
|
|
215802
|
+
} else return super._getBaseGlyph(glyph, characters);
|
|
215803
|
+
}
|
|
215668
215804
|
}
|
|
215669
215805
|
_transformGlyfTable() {
|
|
215670
215806
|
this._decompress();
|
|
@@ -217124,6 +217260,13 @@ function updateTitle(sectionToken, inputs) {
|
|
|
217124
217260
|
}
|
|
217125
217261
|
//#endregion
|
|
217126
217262
|
//#region src/sections/update-usage.ts
|
|
217263
|
+
/**
|
|
217264
|
+
* Renders the `usage` section: a fenced workflow snippet naming every action input,
|
|
217265
|
+
* each preceded by its description and default as YAML comments.
|
|
217266
|
+
* @param {ReadmeSection} sectionToken - The README marker pair to write the section into.
|
|
217267
|
+
* @param {Inputs} inputs - The parsed action metadata and the README editor to write with.
|
|
217268
|
+
* @returns {Promise<Record<string, string>>} The rendered section, keyed by its section token.
|
|
217269
|
+
*/
|
|
217127
217270
|
async function updateUsage(sectionToken, inputs) {
|
|
217128
217271
|
const log = new LogTask(sectionToken);
|
|
217129
217272
|
log.start();
|
|
@@ -217133,6 +217276,8 @@ async function updateUsage(sectionToken, inputs) {
|
|
|
217133
217276
|
log.info(`Version string: ${versionString}`);
|
|
217134
217277
|
const actionReference = `${actionName}@${versionString}`;
|
|
217135
217278
|
const indent = " # ";
|
|
217279
|
+
const defaultLabel = "Default: ";
|
|
217280
|
+
const defaultHang = " ".repeat(9);
|
|
217136
217281
|
const content = [];
|
|
217137
217282
|
content.push("```yaml", `- uses: ${actionReference}`, " with:");
|
|
217138
217283
|
const inp = inputs.action.inputs;
|
|
@@ -217159,7 +217304,11 @@ async function updateUsage(sectionToken, inputs) {
|
|
|
217159
217304
|
if (input !== void 0) {
|
|
217160
217305
|
if (!firstInput) content.push("");
|
|
217161
217306
|
content.push(...descriptions[key]);
|
|
217162
|
-
if (input.default !== void 0)
|
|
217307
|
+
if (input.default !== void 0) {
|
|
217308
|
+
const [firstLine, ...rest] = `${input.default}`.split(/\r\n|\n|\r/);
|
|
217309
|
+
content.push(`${indent}${defaultLabel}${firstLine}`.trimEnd());
|
|
217310
|
+
for (const line of rest) content.push(`${indent}${defaultHang}${line}`.trimEnd());
|
|
217311
|
+
}
|
|
217163
217312
|
content.push(` ${key}: ''`);
|
|
217164
217313
|
firstInput = false;
|
|
217165
217314
|
}
|